l jn:UdZddlmZgdZddlmZmZddlmZddl m Z m Z ddl Z ddlmZe rdd lmZmZmZmZmZmZmZmZmZmZmZmZmZe dgdZe dhdZdidZdjdZdkdZ de!dDZ"de#d<dld$Z$dmd%Z%dnd*Z&e dod.Z'e dpd0Z'e dqd2Z'e drd4Z'dsd8Z'dtd:Z(e dud;Z)e dvd<Z)dwd=Z)e dxd?Z*e dyd@Z*e dzdAZ*d{dBZ*e d|dHZ+e d}dIZ+d~dJZ+ddNZ,e j-dOga.e j-dOga/ddPZ0e j-dQga1ddRZ2e ddYZ3e dd[Z3dd^Z3dd`Z4 dddeZ5 dddfZ6dS)u,Utility functions related to Bézier curves.) annotations)bezierpartial_bezier_points split_beziersubdivide_bezier bezier_remap interpolateinteger_interpolatemidinverse_interpolatematch_interpolate%get_smooth_cubic_bezier_handle_points is_closed(proportions_along_bezier_curve_for_pointpoint_lies_on_bezier)CallableSequence)reduce) TYPE_CHECKINGoverloadN)choose) BezierPointsBezierPoints_ArrayBezierPointsLikeBezierPointsLike_Array ColVectorMatrixMNPoint3D Point3D_Array Point3DLikePoint3DLike_ArrayQuadraticBezierPathQuadraticSplineSplinepointsrreturn6Callable[[float | ColVector], Point3D | Point3D_Array]cdSNr%s M/home/agentuser/manim-venv/lib/python3.11/site-packages/manim/utils/bezier.pyrr4s >ASSequence[Point3DLike_Array],Callable[[float | ColVector], Point3D_Array]cdSr)r*r+s r,rr:s 473r-'Point3D_Array | Sequence[Point3D_Array]ctj|jddz dkrdfd }|Sdkrdfd }|Sd krdfd }|Sd krdfd }|Sdfd }|S)u Classic implementation of a Bézier curve. Parameters ---------- points :math:`(d+1, 3)`-shaped array of :math:`d+1` control points defining a single Bézier curve of degree :math:`d`. Alternatively, for vectorization purposes, ``points`` can also be a :math:`(d+1, M, 3)`-shaped sequence of :math:`d+1` arrays of :math:`M` control points each, which define `M` Bézier curves instead. Returns ------- bezier_func : :class:`typing.Callable` [[:class:`float` | :class:`~.ColVector`], :class:`~.Point3D` | :class:`~.Point3D_Array`] Function describing the Bézier curve. The behaviour of this function depends on the shape of ``points``: * If ``points`` was a :math:`(d+1, 3)` array representing a single Bézier curve, then ``bezier_func`` can receive either: * a :class:`float` ``t``, in which case it returns a single :math:`(1, 3)`-shaped :class:`~.Point3D` representing the evaluation of the Bézier at ``t``, or * an :math:`(n, 1)`-shaped :class:`~.ColVector` containing :math:`n` values to evaluate the Bézier curve at, returning instead an :math:`(n, 3)`-shaped :class:`~.Point3D_Array` containing the points resulting from evaluating the Bézier at each of the :math:`n` values. .. warning:: If passing a vector of :math:`t`-values to ``bezier_func``, it **must** be a column vector/matrix of shape :math:`(n, 1)`. Passing an 1D array of shape :math:`(n,)` is not supported and **will result in undefined behaviour**. * If ``points`` was a :math:`(d+1, M, 3)` array describing :math:`M` Bézier curves, then ``bezier_func`` can receive either: * a :class:`float` ``t``, in which case it returns an :math:`(M, 3)`-shaped :class:`~.Point3D_Array` representing the evaluation of the :math:`M` Bézier curves at the same value ``t``, or * an :math:`(M, 1)`-shaped :class:`~.ColVector` containing :math:`M` values, such that the :math:`i`-th Bézier curve defined by ``points`` is evaluated at the corresponding :math:`i`-th value in ``t``, returning again an :math:`(M, 3)`-shaped :class:`~.Point3D_Array` containing those :math:`M` evaluations. .. warning:: Unlike the previous case, if you pass a :class:`~.ColVector` to ``bezier_func``, it **must** contain exactly :math:`M` values, each value for each of the :math:`M` Bézier curves defined by ``points``. Any array of shape other than :math:`(M, 1)` **will result in undefined behaviour**. rtfloat | ColVectorr&Point3D | Point3D_Arrayc>tj|dzS)Nr)np ones_liker4Ps r, zero_bezierzbezier..zero_bezierzs<??QqT) )r-c>d|ddz zzS)Nrr3r*r:s r, linear_bezierzbezier..linear_beziers#Q4!qtad{++ +r-ct||z}d|z }||z}|dzd|z|zdzz|dzzS)Nr3rr?r*)r4t2mtmt2r;s r,quadratic_bezierz bezier..quadratic_beziersOQBQBr'C1:A QqT 11B1I= =r-c||z}||z}d|z }||z}||z}|dzd|z|zdzzd|z|zdzz|dzzS)Nr3rrEr?r*)r4rAt3rBrCmt3r;s r, cubic_bezierzbezier..cubic_beziersxQBaBQBr'C(C1:A ad 22QVb[1Q45GG"qQRt)S Sr-c t|tj }|rtjdgjR}nat|tjsJ|jdgdjDR}tj|jdgjR}|dd<t D]B}|ddd|z fxx||ddd|z dzf|ddd|z fz zz cc<C|r |d}|S|dddfS)Nr3cg|]}dS)r3r*).0dims r, z4bezier..nth_grade_bezier..s555c555r-rrr) isinstancer8ndarrayemptyshapereshaperange)r4 is_scalarBivalr;degrees r,nth_grade_bezierz bezier..nth_grade_beziersW"1bj111  1!ag''AAa,, , ,, "655QW555666A!'!*/qw//00A!!!v V VA aaa6A:o   !qA Q,>)>'?!AAA|RS|OBT'T"U U      T7CJAwr-)r4r5r&r6)r8asarrayrT)r%r<r>rDrIr\r;r[s @@r,rr@sj 6A WQZ!^F {{ * * * * * * {{ , , , , , , {{ > > > > > >   {{ T T T T T T, r-afloatbrc b|dkr#tj|}|d|dd<|S|dkr#tj|}|d|dd<|Stj|}|jddz }|dkrd|z d|z }}||z||z||z||zf\}}} } ||z||z| |z| |zf\} } } }tj| d| z|zd|z|z| g| |zd|z|z|z| |zz||zd|z|z|zz||zg|| z|| zd|z|z|zzd|z|z|z||zz||zg|d| z|zd|z|z| gg}||zS|dkrVd|z d|z }}tj||zd|z|z||zg||z||z||zz||zg||zd|z|z||zgg}||zS|dkr?|d|dz }tj|d||zz|d||zzgS|dkr|Stj|t}|jd}|dkrGt d|D]6}|d||z xx||d||z dz|d||z z zz cc<7|dkrId|z d|z z }t d|D]-}||dxx|||dz d||dz zz cc<.|S)uPGiven an array of ``points`` which define a Bézier curve, and two numbers :math:`a, b` such that :math:`0 \le a < b \le 1`, return an array of the same size, which describes the portion of the original Bézier curve on the interval :math:`[a, b]`. :func:`partial_bezier_points` is conceptually equivalent to calling :func:`split_bezier` twice and discarding unused Bézier curves, but this is more efficient and doesn't waste computations. .. seealso:: See :func:`split_bezier` for an explanation on how to split Bézier curves. .. note:: To find the portion of a Bézier curve with :math:`t` between :math:`a` and :math:`b`: 1. Split the curve at :math:`t = a` and extract its 2nd subcurve. 2. We cannot evaluate the new subcurve at :math:`t = b` because its range of values for :math:`t` is different. To find the correct value, we need to transform the interval :math:`[a, 1]` into :math:`[0, 1]` by first subtracting :math:`a` to get :math:`[0, 1-a]` and then dividing by :math:`1-a`. Thus, our new value must be :math:`t = \frac{b - a}{1 - a}`. Define :math:`u = \frac{b - a}{1 - a}`. 3. Split the subcurve at :math:`t = u` and extract its 1st subcurve. The final portion is a linear combination of points, and thus the process can be summarized as a linear transformation by some matrix in terms of :math:`a` and :math:`b`. This matrix is given explicitly for Bézier curves up to degree 3, which are often used in Manim. For higher degrees, the algorithm described previously is used. For the case of a quadratic Bézier curve: * Step 1: .. math:: H'_1 = \begin{pmatrix} (1-a)^2 & 2(1-a)a & a^2 \\ 0 & (1-a) & a \\ 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} p_0 \\ p_1 \\ p_2 \end{pmatrix} * Step 2: .. math:: H''_0 &= \begin{pmatrix} 1 & 0 & 0 \\ (1-u) & u & 0\\ (1-u)^2 & 2(1-u)u & u^2 \end{pmatrix} H'_1 \\ & \\ &= \begin{pmatrix} 1 & 0 & 0 \\ (1-u) & u & 0\\ (1-u)^2 & 2(1-u)u & u^2 \end{pmatrix} \begin{pmatrix} (1-a)^2 & 2(1-a)a & a^2 \\ 0 & (1-a) & a \\ 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} p_0 \\ p_1 \\ p_2 \end{pmatrix} \\ & \\ &= \begin{pmatrix} (1-a)^2 & 2(1-a)a & a^2 \\ (1-a)(1-b) & a(1-b) + (1-a)b & ab \\ (1-b)^2 & 2(1-b)b & b^2 \end{pmatrix} \begin{pmatrix} p_0 \\ p_1 \\ p_2 \end{pmatrix} from where one can define a :math:`(3, 3)` matrix :math:`P_2` which, when applied over the array of ``points``, will return the desired partial quadratic Bézier curve: .. math:: P_2 = \begin{pmatrix} (1-a)^2 & 2(1-a)a & a^2 \\ (1-a)(1-b) & a(1-b) + (1-a)b & ab \\ (1-b)^2 & 2(1-b)b & b^2 \end{pmatrix} Similarly, for the cubic Bézier curve case, one can define the following :math:`(4, 4)` matrix :math:`P_3`: .. math:: P_3 = \begin{pmatrix} (1-a)^3 & 3(1-a)^2a & 3(1-a)a^2 & a^3 \\ (1-a)^2(1-b) & 2(1-a)a(1-b) + (1-a)^2b & a^2(1-b) + 2(1-a)ab & a^2b \\ (1-a)(1-b)^2 & a(1-b)^2 + 2(1-a)(1-b)b & 2a(1-b)b + (1-a)b^2 & ab^2 \\ (1-b)^3 & 3(1-b)^2b & 3(1-b)b^2 & b^3 \end{pmatrix} Parameters ---------- points set of points defining the bezier curve. a lower bound of the desired partial bezier curve. b upper bound of the desired partial bezier curve. Returns ------- :class:`~.BezierPoints` An array containing the control points defining the partial Bézier curve. r3rKNrrEr?dtype)r8arrayr]rTr_rV)r%r^r`arrr[mamba2b2ma2mb2a3b3ma3mb3portion_matrix directionNrYmus r,rrsD AvvhvRAAA AvvhvQAAA Z  F \!_q F {{QABq5!a%b"r'9BS62638S2X=BSa#gk1r6B;3r1r6A:?S1W4b2gB Q6NPRUVPVWc1s7QVb[1_4a!ebj1nrBw6NPQTVPVWa#gk1r6B;3    && {{QABb!a%"*a!e,b!b&26/1q51b!a%"*a!e,   && {{1Iq ) xq A M)q A M)    {{  (6 ' ' 'C ! A Avvq! D DA !a%LLLAQQ]!3c'AE'l!BC CLLLL Avv!eA q! 8 8A GGGrSQ_s122w67 7GGGG Jr-r4r$c tj|}|j\}}|dz }|dkrnd|z }||z}||z}||z}||z} d|z|z} d|z|z} d|z|z} tjgd||ddg|| |dg|| | | g|| | | gd|| |gdd||ggdg} | |zS|dkrFd|z }||z}||z}d|z|z}tjgd||dg|||g|||gd||ggdg} | |zS|dkrA|d||d|dz zz}tj|d|||dgS|dkr"tj|d|dgStjd||f}||d<|d|d <t d|D]I}|dd ||z fxx||dd||z dzf|dd ||z fz zz cc<|d |d|f<J|d|z|S) uSplit a Bézier curve at argument ``t`` into two curves. .. note:: .. seealso:: `A Primer on Bézier Curves #10: Splitting curves. Pomax. `_ As an example for a cubic Bézier curve, let :math:`p_0, p_1, p_2, p_3` be the points needed for the curve :math:`C_0 = [p_0, \ p_1, \ p_2, \ p_3]`. Define the 3 linear Béziers :math:`L_0, L_1, L_2` as interpolations of :math:`p_0, p_1, p_2, p_3`: .. math:: L_0(t) &= p_0 + t(p_1 - p_0) \\ L_1(t) &= p_1 + t(p_2 - p_1) \\ L_2(t) &= p_2 + t(p_3 - p_2) Define the 2 quadratic Béziers :math:`Q_0, Q_1` as interpolations of :math:`L_0, L_1, L_2`: .. math:: Q_0(t) &= L_0(t) + t(L_1(t) - L_0(t)) \\ Q_1(t) &= L_1(t) + t(L_2(t) - L_1(t)) Then :math:`C_0` is the following interpolation of :math:`Q_0` and :math:`Q_1`: .. math:: C_0(t) = Q_0(t) + t(Q_1(t) - Q_0(t)) Evaluating :math:`C_0` at a value :math:`t=t'` splits :math:`C_0` into two cubic Béziers :math:`H_0` and :math:`H_1`, defined by some of the points we calculated earlier: .. math:: H_0 &= [p_0, &\ L_0(t'), &\ Q_0(t'), &\ C_0(t') &] \\ H_1 &= [p_0(t'), &\ Q_1(t'), &\ L_2(t'), &\ p_3 &] As the resulting curves are obtained from linear combinations of ``points``, everything can be encoded into a matrix for efficiency, which is done for Bézier curves of degree up to 3. .. seealso:: `A Primer on Bézier Curves #11: Splitting curves using matrices. Pomax. `_ For the simpler case of a quadratic Bézier curve: .. math:: H_0 &= \begin{pmatrix} p_0 \\ (1-t) p_0 + t p_1 \\ (1-t)^2 p_0 + 2(1-t)t p_1 + t^2 p_2 \\ \end{pmatrix} &= \begin{pmatrix} 1 & 0 & 0 \\ (1-t) & t & 0\\ (1-t)^2 & 2(1-t)t & t^2 \end{pmatrix} \begin{pmatrix} p_0 \\ p_1 \\ p_2 \end{pmatrix} \\ & \\ H_1 &= \begin{pmatrix} (1-t)^2 p_0 + 2(1-t)t p_1 + t^2 p_2 \\ (1-t) p_1 + t p_2 \\ p_2 \end{pmatrix} &= \begin{pmatrix} (1-t)^2 & 2(1-t)t & t^2 \\ 0 & (1-t) & t \\ 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} p_0 \\ p_1 \\ p_2 \end{pmatrix} from where one can define a :math:`(6, 3)` split matrix :math:`S_2` which can multiply the array of ``points`` to compute the return value: .. math:: S_2 &= \begin{pmatrix} 1 & 0 & 0 \\ (1-t) & t & 0 \\ (1-t)^2 & 2(1-t)t & t^2 \\ (1-t)^2 & 2(1-t)t & t^2 \\ 0 & (1-t) & t \\ 0 & 0 & 1 \end{pmatrix} \\ & \\ S_2 P &= \begin{pmatrix} 1 & 0 & 0 \\ (1-t) & t & 0 \\ (1-t)^2 & 2(1-t)t & t^2 \\ (1-t)^2 & 2(1-t)t & t^2 \\ 0 & (1-t) & t \\ 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} p_0 \\ p_1 \\ p_2 \end{pmatrix} = \begin{pmatrix} \vert \\ H_0 \\ \vert \\ \vert \\ H_1 \\ \vert \end{pmatrix} For the previous example with a cubic Bézier curve: .. math:: H_0 &= \begin{pmatrix} p_0 \\ (1-t) p_0 + t p_1 \\ (1-t)^2 p_0 + 2(1-t)t p_1 + t^2 p_2 \\ (1-t)^3 p_0 + 3(1-t)^2 t p_1 + 3(1-t)t^2 p_2 + t^3 p_3 \end{pmatrix} &= \begin{pmatrix} 1 & 0 & 0 & 0 \\ (1-t) & t & 0 & 0 \\ (1-t)^2 & 2(1-t)t & t^2 & 0 \\ (1-t)^3 & 3(1-t)^2 t & 3(1-t)t^2 & t^3 \end{pmatrix} \begin{pmatrix} p_0 \\ p_1 \\ p_2 \\ p_3 \end{pmatrix} \\ & \\ H_1 &= \begin{pmatrix} (1-t)^3 p_0 + 3(1-t)^2 t p_1 + 3(1-t)t^2 p_2 + t^3 p_3 \\ (1-t)^2 p_1 + 2(1-t)t p_2 + t^2 p_3 \\ (1-t) p_2 + t p_3 \\ p_3 \end{pmatrix} &= \begin{pmatrix} (1-t)^3 & 3(1-t)^2 t & 3(1-t)t^2 & t^3 \\ 0 & (1-t)^2 & 2(1-t)t & t^2 \\ 0 & 0 & (1-t) & t \\ 0 & 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} p_0 \\ p_1 \\ p_2 \\ p_3 \end{pmatrix} from where one can define a :math:`(8, 4)` split matrix :math:`S_3` which can multiply the array of ``points`` to compute the return value: .. math:: S_3 &= \begin{pmatrix} 1 & 0 & 0 & 0 \\ (1-t) & t & 0 & 0 \\ (1-t)^2 & 2(1-t)t & t^2 & 0 \\ (1-t)^3 & 3(1-t)^2 t & 3(1-t)t^2 & t^3 \\ (1-t)^3 & 3(1-t)^2 t & 3(1-t)t^2 & t^3 \\ 0 & (1-t)^2 & 2(1-t)t & t^2 \\ 0 & 0 & (1-t) & t \\ 0 & 0 & 0 & 1 \end{pmatrix} \\ & \\ S_3 P &= \begin{pmatrix} 1 & 0 & 0 & 0 \\ (1-t) & t & 0 & 0 \\ (1-t)^2 & 2(1-t)t & t^2 & 0 \\ (1-t)^3 & 3(1-t)^2 t & 3(1-t)t^2 & t^3 \\ (1-t)^3 & 3(1-t)^2 t & 3(1-t)t^2 & t^3 \\ 0 & (1-t)^2 & 2(1-t)t & t^2 \\ 0 & 0 & (1-t) & t \\ 0 & 0 & 0 & 1 \end{pmatrix} \begin{pmatrix} p_0 \\ p_1 \\ p_2 \\ p_3 \end{pmatrix} = \begin{pmatrix} \vert \\ H_0 \\ \vert \\ \vert \\ H_1 \\ \vert \end{pmatrix} Parameters ---------- points The control points of the Bézier curve. t The ``t``-value at which to split the Bézier curve. Returns ------- :class:`~.Point3D_Array` An array containing the control points defining the two Bézier curves. r3rEr?)r3rrrr)rrrr3)r3rr)rrr3rPN)r3r)r8r]rTrdrSrVrU)r%r4rrrNr[rBrCrHrArGtwo_mt_t three_mt2_t three_mt_t2 split_matrixtwo_tmtmiddlererYs r,rrsXZ  F \FAs UF {{ U2gBh U !Vr6A:#gk "frk x Q1 hA&k;3k;3C2&Ar1      f$$ {{ U2g Ua%"*x Q gr"gr"B      f$$ {{Q&)fQi"788xFFF1I>??? {{xF1I./// (Aq#;  C CFq CI 1a[[ AwQwJ1Aq1q519}$4 5AwQwJ GHHIAqD ;;q1uc " ""r-cg|]}iSr*r*)rMrYs r,rOrOs2H2H2H!22H2H2Hr-zlist[dict[int, MatrixMN]]SUBDIVISION_MATRICESn_pointsint n_divisionsrc |dvrtdt|dz |d}||Stj||z|f}|dkrt |D]}||z}||z}|dz}||z}||z}||z } | | z} | | z} | dz } | | z} | | z}tj| d| z|zd| z|z|g| | zd| z| z|z| |zz| |zd| z|z|zz||zg| | z| |zd| z| z|zzd| z|z|z| |zz||zg|d| z|zd| z|z|gg|d|zd|dzz<|||z|zz}n|dkrt |D]f}|dz}||z } | dz } tj| | zd|z| z||zg| | z|| z|| zz||zg| | zd|z| z||zgg|d|zd|dzz<g|||zz}nh|dkrUtj|dz}|dd|ddddf<|dd|ddddf<|ddddf|ddd f<||z}n |dkrd|dd<|t|dz |<|S) uGets the matrix which subdivides a Bézier curve of ``n_points`` control points into ``n_divisions`` parts. Auxiliary function for :func:`subdivide_bezier`. See its docstrings for an explanation of the matrix build process. Parameters ---------- n_points The number of control points of the Bézier curve to subdivide. This function only handles up to 4 points. n_divisions The number of parts to subdivide the Bézier curve into. Returns ------- MatrixMN The matrix which, upon multiplying the control points of the Bézier curve, subdivides it into ``n_divisions`` parts. )r3r?rEr|u_This function does not support subdividing Bézier curves with 0 or more than 4 control points.r3Nr|rEr?rKr)NotImplementedErrorr}getr8rSrVrdarange)r~rsubdivision_matrixrYi2i3ip1ip12ip13nminmi2nmi3nmim1nmim12nmim13 aux_ranges r,_get_subdivision_matrixrs*|##! ;   .hl;?? TRR%!!8k#98"DEE1}}{##( ( AQBaBa%C9D#:D/C9D#:D!GEU]Fe^F68hD1 C"  u C%!+dSj8 QWq[3%66S f  QWu_s%::E A +cDj8D F S(E D( '77 q1uqAE{2 3 38 kK7+EE Q{##  Aa%C/C!GE68h3YA QU35[!e)cCi"7SAU]AGeOS3Y?77 q1uqAE{2 3 3 kK77 QIkAo.. %.ss^33Q36"&/m14a47##5dddAg#>111a4 k) Q !1116HA&{3 r-c tj|}|dkr|S|j\}}|dkrt||}||zStj|||f}||d<t |dz ddD]}||}||dz }|d|d<||z ||z dzz } t d|D]A} |d|| z xx| |d|| z dz|d|| z z zz cc<|d|| <B|||z|S)u Subdivide a Bézier curve into :math:`n` subcurves which have the same shape. The points at which the curve is split are located at the arguments :math:`t = \frac{i}{n}`, for :math:`i \in \{1, ..., n-1\}`. .. seealso:: * See :func:`split_bezier` for an explanation on how to split Bézier curves. * See :func:`partial_bezier_points` for an extra understanding of this function. .. note:: The resulting subcurves can be expressed as linear combinations of ``points``, which can be encoded in a single matrix that is precalculated for 2nd and 3rd degree Bézier curves. As an example for a quadratic Bézier curve: taking inspiration from the explanation in :func:`partial_bezier_points`, where the following matrix :math:`P_2` was defined to extract the portion of a quadratic Bézier curve for :math:`t \in [a, b]`: .. math:: P_2 = \begin{pmatrix} (1-a)^2 & 2(1-a)a & a^2 \\ (1-a)(1-b) & a(1-b) + (1-a)b & ab \\ (1-b)^2 & 2(1-b)b & b^2 \end{pmatrix} the plan is to replace :math:`[a, b]` with :math:`\left[ \frac{i-1}{n}, \frac{i}{n} \right], \ \forall i \in \{1, ..., n\}`. As an example for :math:`n = 2` divisions, construct :math:`P_1` for the interval :math:`\left[ 0, \frac{1}{2} \right]`, and :math:`P_2` for the interval :math:`\left[ \frac{1}{2}, 1 \right]`: .. math:: P_1 = \begin{pmatrix} 1 & 0 & 0 \\ 0.5 & 0.5 & 0 \\ 0.25 & 0.5 & 0.25 \end{pmatrix} , \quad P_2 = \begin{pmatrix} 0.25 & 0.5 & 0.25 \\ 0 & 0.5 & 0.5 \\ 0 & 0 & 1 \end{pmatrix} Therefore, the following :math:`(6, 3)` subdivision matrix :math:`D_2` can be constructed, which will subdivide an array of ``points`` into 2 parts: .. math:: D_2 = \begin{pmatrix} M_1 \\ M_2 \end{pmatrix} = \begin{pmatrix} 1 & 0 & 0 \\ 0.5 & 0.5 & 0 \\ 0.25 & 0.5 & 0.25 \\ 0.25 & 0.5 & 0.25 \\ 0 & 0.5 & 0.5 \\ 0 & 0 & 1 \end{pmatrix} For quadratic and cubic Bézier curves, the subdivision matrices are memoized for efficiency. For higher degree curves, an iterative algorithm inspired by the one from :func:`split_bezier` is used instead. .. image:: /_static/bezier_subdivision_example.png Parameters ---------- points The control points of the Bézier curve. n_divisions The number of curves to subdivide the Bézier curve into Returns ------- :class:`~.Spline` An array containing the points defining the new :math:`n` subcurves. r3r|rKrN)r8r]rTrrSrVrU) r%rrrrNrbeziers curve_numcurrprevr^rYs r,rr9sa~Z  Fa \FAsAvv4Q DD!F**h Q,--GGBK;?Ar22 y!y1}%q'Q 9 $y)@1)D Eq!  A 1q5MMMQ$q1q519}"5Wq1uW "EF FMMM1gDGG  ??;?C 0 00r- bezier_tuplesrnew_number_of_curvesrctj|}|j\}}}tj|d|z|z}tj|d}tj||dtj|||f}d}t||dD]7\} } t| |  | |||||| z<|| z }8|S)uSubdivides each curve in ``bezier_tuples`` into as many parts as necessary, until the final number of curves reaches a desired amount, ``new_number_of_curves``. Parameters ---------- bezier_tuples An array of multiple Bézier curves of degree :math:`d` to be remapped. The shape of this array must be ``(current_number_of_curves, nppc, dim)``, where: * ``current_number_of_curves`` is the current amount of curves in the array ``bezier_tuples``, * ``nppc`` is the amount of points per curve, such that their degree is ``nppc-1``, and * ``dim`` is the dimension of the points, usually :math:`3`. new_number_of_curves The number of curves that the output will contain. This needs to be higher than the current number. Returns ------- :class:`~.BezierPoints_Array` The new array of shape ``(new_number_of_curves, nppc, dim)``, containing the new Bézier curves after the remap. rYrbr3rT)strict) r8r]rTrzerosaddatrSziprrU) rrcurrent_number_of_curvesnppcrNrepeat_indices split_factors new_tuplesindexcurvesfs r,rrs4J}--M*7*='dC &c2225MM NH5SAAAMFIIm^Q////s;<>> integer, residue = integer_interpolate(start=0, end=10, alpha=0.46) >>> np.allclose((integer, residue), (4, 0.6)) True r3g?r)rr )rrrvalueresidues r,r r +ssF zzC!G c"" zzE A  E3.. / /Ee u$)G 7 r-cdSr)r*rrs r,r r Ws,/Cr-cdSr)r*rs r,r r [s25#r-c||zdz S)zReturns the midpoint between two values. Parameters ---------- start The first value end The second value Returns ------- The midpoint between the two values g@r*rs r,r r _s CK3 r-rcdSr)r*rrrs r,r r prr-cdSr)r*rs r,r r tsNQcr-cdSr)r*rs r,r r xrr-c8tj||z ||z S)auPerform inverse interpolation to determine the alpha values that would produce the specified ``value`` given the ``start`` and ``end`` values or points. Parameters ---------- start The start value or point of the interpolation. end The end value or point of the interpolation. value The value or point for which the alpha value should be determined. Returns ------- The alpha values producing the given input when interpolating between ``start`` and ``end``. Example ------- .. code-block:: pycon >>> inverse_interpolate(start=2, end=6, value=4) np.float64(0.5) >>> start = np.array([1, 2, 1]) >>> end = np.array([7, 8, 11]) >>> value = np.array([4, 5, 5]) >>> inverse_interpolate(start, end, value) array([0.5, 0.5, 0.4]) )r8 true_dividers r,r r |sL >%%-u 5 55r- new_startnew_end old_startold_end old_valuecdSr)r*rrrrrs r,r r s  Cr-cdSr)r*rs r,r r s cr-cFt|||}t|||S)aInterpolate a value from an old range to a new range. Parameters ---------- new_start The start of the new range. new_end The end of the new range. old_start The start of the old range. old_end The end of the old range. old_value The value within the old range whose corresponding value in the new range (with the same alpha value) is desired. Returns ------- The interpolated value within the new range. Examples -------- >>> from manim import match_interpolate >>> match_interpolate(0, 100, 10, 20, 15) np.float64(50.0) )r r )rrrrr old_alphas r,r r s1D$Iw BBI   r-anchorsr!#tuple[Point3D_Array, Point3D_Array]ctj|}|jd}|dkr9|jd}tjd|ftjd|ffS|dkrCt |d|dtjdgdgg}|d|dfSt |}|rt|St|S)uGiven an array of anchors for a cubic spline (array of connected cubic Bézier curves), compute the 1st and 2nd handle for every curve, so that the resulting spline is smooth. Parameters ---------- anchors Anchors of a cubic spline. Returns ------- :class:`tuple` [:class:`~.Point3D_Array`, :class:`~.Point3D_Array`] A tuple of two arrays: one containing the 1st handle for every curve in the cubic spline, and the other containing the 2nd handles. rr3r?UUUUUU?gUUUUUU?) r8r]rTrr rdr,get_smooth_closed_cubic_bezier_handle_points*get_smooth_open_cubic_bezier_handle_points)r n_anchorsrNrZcurve_is_closeds r,rrs$j!!G a IA~~mAxC!!28QH#5#555 A~~'!*gaj"(UGeW;M2N2NOOAA ((OC;GDDD9'BBBr-rctj|}|jddz }|jd}tj}||dz krtj|dz }tj|dz }t|d|<t |d|<t||dz D].}dd||dz z z ||<|| ||dz z||</|a|an$td|dz }t d|dz }dd||dz z z }|d||dz z z} tj||f} | | |dz <t|dz ddD]"}||||| |dzzz | |<#tj||f} d|d|zd|ddzz} | ddz | d<td|dz D]"}||| || |dz z z| |<#|| |dz | |dz z z| |dz <| } t|dz ddD]"}| |||| |dzzz | |<#| dd| dz| |dz zz | z| d| |dz zzz }tj||f}d|d|z|d|z |d|dz <d||z|dz ||dz <||fS)u!Special case of :func:`get_smooth_cubic_bezier_handle_points`, when the ``anchors`` form a closed loop. .. note:: A system of equations must be solved to get the first handles of every Bézier curve (referred to as :math:`H_1`). Then :math:`H_2` (the second handles) can be obtained separately. .. seealso:: The equations were obtained from: * `Conditions on control points for continuous curvature. (2016). Jaco Stuifbergen. `_ In general, if there are :math:`N+1` anchors, there will be :math:`N` Bézier curves and thus :math:`N` pairs of handles to find. We must solve the following system of equations for the 1st handles (example for :math:`N = 5`): .. math:: \begin{pmatrix} 4 & 1 & 0 & 0 & 1 \\ 1 & 4 & 1 & 0 & 0 \\ 0 & 1 & 4 & 1 & 0 \\ 0 & 0 & 1 & 4 & 1 \\ 1 & 0 & 0 & 1 & 4 \end{pmatrix} \begin{pmatrix} H_{1,0} \\ H_{1,1} \\ H_{1,2} \\ H_{1,3} \\ H_{1,4} \end{pmatrix} = \begin{pmatrix} 4A_0 + 2A_1 \\ 4A_1 + 2A_2 \\ 4A_2 + 2A_3 \\ 4A_3 + 2A_4 \\ 4A_4 + 2A_5 \end{pmatrix} which will be expressed as :math:`RH_1 = D`. :math:`R` is almost a tridiagonal matrix, so we could use Thomas' algorithm. .. seealso:: `Tridiagonal matrix algorithm. Wikipedia. `_ However, :math:`R` has ones at the opposite corners. A solution to this is the first decomposition proposed in the link below, with :math:`\alpha = 1`: .. seealso:: `Tridiagonal matrix algorithm # Variants. Wikipedia. `_ .. math:: R = \begin{pmatrix} 4 & 1 & 0 & 0 & 1 \\ 1 & 4 & 1 & 0 & 0 \\ 0 & 1 & 4 & 1 & 0 \\ 0 & 0 & 1 & 4 & 1 \\ 1 & 0 & 0 & 1 & 4 \end{pmatrix} &= \begin{pmatrix} 3 & 1 & 0 & 0 & 0 \\ 1 & 4 & 1 & 0 & 0 \\ 0 & 1 & 4 & 1 & 0 \\ 0 & 0 & 1 & 4 & 1 \\ 0 & 0 & 0 & 1 & 3 \end{pmatrix} + \begin{pmatrix} 1 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 0 & 1 \end{pmatrix} \\ & \\ &= \begin{pmatrix} 3 & 1 & 0 & 0 & 0 \\ 1 & 4 & 1 & 0 & 0 \\ 0 & 1 & 4 & 1 & 0 \\ 0 & 0 & 1 & 4 & 1 \\ 0 & 0 & 0 & 1 & 3 \end{pmatrix} + \begin{pmatrix} 1 \\ 0 \\ 0 \\ 0 \\ 1 \end{pmatrix} \begin{pmatrix} 1 & 0 & 0 & 0 & 1 \end{pmatrix} \\ & \\ &= T + uv^t We decompose :math:`R = T + uv^t`, where :math:`T` is a tridiagonal matrix, and :math:`u, v` are :math:`N`-D vectors such that :math:`u_0 = u_{N-1} = v_0 = v_{N-1} = 1`, and :math:`u_i = v_i = 0, \forall i \in \{1, ..., N-2\}`. Thus: .. math:: RH_1 &= D \\ \Rightarrow (T + uv^t)H_1 &= D If we find a vector :math:`q` such that :math:`Tq = u`: .. math:: \Rightarrow (T + Tqv^t)H_1 &= D \\ \Rightarrow T(I + qv^t)H_1 &= D \\ \Rightarrow H_1 &= (I + qv^t)^{-1} T^{-1} D According to Sherman-Morrison's formula: .. seealso:: `Sherman-Morrison's formula. Wikipedia. `_ .. math:: (I + qv^t)^{-1} = I - \frac{1}{1 + v^tq} qv^t If we find :math:`Y = T^{-1} D`, or in other words, if we solve for :math:`Y` in :math:`TY = D`: .. math:: H_1 &= (I + qv^t)^{-1} T^{-1} D \\ &= (I + qv^t)^{-1} Y \\ &= (I - \frac{1}{1 + v^tq} qv^t) Y \\ &= Y - \frac{1}{1 + v^tq} qv^tY Therefore, we must solve for :math:`q` and :math:`Y` in :math:`Tq = u` and :math:`TY = D`. As :math:`T` is now tridiagonal, we shall use Thomas' algorithm. Define: * :math:`a = [a_0, \ a_1, \ ..., \ a_{N-2}]` as :math:`T`'s lower diagonal of :math:`N-1` elements, such that :math:`a_0 = a_1 = ... = a_{N-2} = 1`, so this diagonal is filled with ones; * :math:`b = [b_0, \ b_1, \ ..., \ b_{N-2}, \ b_{N-1}]` as :math:`T`'s main diagonal of :math:`N` elements, such that :math:`b_0 = b_{N-1} = 3`, and :math:`b_1 = b_2 = ... = b_{N-2} = 4`; * :math:`c = [c_0, \ c_1, \ ..., \ c_{N-2}]` as :math:`T`'s upper diagonal of :math:`N-1` elements, such that :math:`c_0 = c_1 = ... = c_{N-2} = 1`: this diagonal is also filled with ones. If, according to Thomas' algorithm, we define: .. math:: c'_0 &= \frac{c_0}{b_0} & \\ c'_i &= \frac{c_i}{b_i - a_{i-1} c'_{i-1}}, & \quad \forall i \in \{1, ..., N-2\} \\ & & \\ u'_0 &= \frac{u_0}{b_0} & \\ u'_i &= \frac{u_i - a_{i-1} u'_{i-1}}{b_i - a_{i-1} c'_{i-1}}, & \quad \forall i \in \{1, ..., N-1\} \\ & & \\ D'_0 &= \frac{1}{b_0} D_0 & \\ D'_i &= \frac{1}{b_i - a_{i-1} c'_{i-1}} (D_i - a_{i-1} D'_{i-1}), & \quad \forall i \in \{1, ..., N-1\} Then: .. math:: c'_0 &= \frac{1}{3} & \\ c'_i &= \frac{1}{4 - c'_{i-1}}, & \quad \forall i \in \{1, ..., N-2\} \\ & & \\ u'_0 &= \frac{1}{3} & \\ u'_i &= \frac{-u'_{i-1}}{4 - c'_{i-1}} = -c'_i u'_{i-1}, & \quad \forall i \in \{1, ..., N-2\} \\ u'_{N-1} &= \frac{1 - u'_{N-2}}{3 - c'_{N-2}} & \\ & & \\ D'_0 &= \frac{1}{3} (4A_0 + 2A_1) & \\ D'_i &= \frac{1}{4 - c'_{i-1}} (4A_i + 2A_{i+1} - D'_{i-1}) & \\ &= c_i (4A_i + 2A_{i+1} - D'_{i-1}), & \quad \forall i \in \{1, ..., N-2\} \\ D'_{N-1} &= \frac{1}{3 - c'_{N-2}} (4A_{N-1} + 2A_N - D'_{N-2}) & Finally, we can do Backward Substitution to find :math:`q` and :math:`Y`: .. math:: q_{N-1} &= u'_{N-1} & \\ q_i &= u'_{i} - c'_i q_{i+1}, & \quad \forall i \in \{0, ..., N-2\} \\ & & \\ Y_{N-1} &= D'_{N-1} & \\ Y_i &= D'_i - c'_i Y_{i+1}, & \quad \forall i \in \{0, ..., N-2\} With those values, we can finally calculate :math:`H_1 = Y - \frac{1}{1 + v^tq} qv^tY`. Given that :math:`v_0 = v_{N-1} = 1`, and :math:`v_1 = v_2 = ... = v_{N-2} = 0`, its dot products with :math:`q` and :math:`Y` are respectively :math:`v^tq = q_0 + q_{N-1}` and :math:`v^tY = Y_0 + Y_{N-1}`. Thus: .. math:: H_1 = Y - \frac{1}{1 + q_0 + q_{N-1}} q(Y_0 + Y_{N-1}) Once we have :math:`H_1`, we can get :math:`H_2` (the array of second handles) as follows: .. math:: H_{2, i} &= 2A_{i+1} - H_{1, i+1}, & \quad \forall i \in \{0, ..., N-2\} \\ H_{2, N-1} &= 2A_0 - H_{1, 0} & Because the matrix :math:`R` always follows the same pattern (and thus :math:`T, u, v` as well), we can define a memo list for :math:`c'` and :math:`u'` to avoid recalculation. We cannot memoize :math:`D` and :math:`Y`, however, because they are always different matrices. We cannot make a memo for :math:`q` either, but we can calculate it faster because :math:`u'` can be memoized. Parameters ---------- anchors Anchors of a closed cubic spline. Returns ------- :class:`tuple` [:class:`~.Point3D_Array`, :class:`~.Point3D_Array`] A tuple of two arrays: one containing the 1st handle for every curve in the closed cubic spline, and the other containing the 2nd handles. rr3Nr|rEr?rK)r8r]rTCP_CLOSED_MEMOsizerSUP_CLOSED_MEMOrV)rArrrNlen_memocpuprYcp_last_divisionup_lastqDpAUXYH1H2s r,rrs?F 7A  QA '!*C"H!a% Xa!e__ Xa!e__&9H9 &9H9 xQ'' ' 'ARAY'BqEUFRAY&BqEE Ga!eG $ Ga!eG $A1q5 M*!bQi-0G !SAAa!eH 1q5"b ! !((!ur!uqQx''! 1c(  B ae)a!ABB%i C FQJBqE 1a!e__--1Q"QU)+,1 CAJAE$:;Bq1uI A 1q5"b ! !((!ur!uqQx''! Q!ad(Qq1uX% & *adQq1uXo > >B 1c(  B!A#JAaC(Bq1q5yMAaD2a5 Bq1uI r6Mr-?ctj|}|jddz }|jd}tj}||dz krPtj|dz }t|d|<t ||dz D]}dd||dz z z ||<|antd|dz }tj||f}d|dz|dz|d<d|d|dz zd|d|zz}t d|dz D]%}||||dz ||dz z z||<&ddd||dz zz z d||dz z||zd||dz zz z||dz <|} t |dz d d D]"}||||| |dzzz | |<#tj||f} d|d|z| d|z | d|dz <d||| |dz zz| |dz <| | fS) uTSpecial case of :func:`get_smooth_cubic_bezier_handle_points`, when the ``anchors`` do not form a closed loop. .. note:: A system of equations must be solved to get the first handles of every Bèzier curve (referred to as :math:`H_1`). Then :math:`H_2` (the second handles) can be obtained separately. .. seealso:: The equations were obtained from: * `Smooth Bézier Spline Through Prescribed Points. (2012). Particle in Cell Consulting LLC. `_ * `Conditions on control points for continuous curvature. (2016). Jaco Stuifbergen. `_ .. warning:: The equations in the first webpage have some typos which were corrected in the comments. In general, if there are :math:`N+1` anchors, there will be :math:`N` Bézier curves and thus :math:`N` pairs of handles to find. We must solve the following system of equations for the 1st handles (example for :math:`N = 5`): .. math:: \begin{pmatrix} 2 & 1 & 0 & 0 & 0 \\ 1 & 4 & 1 & 0 & 0 \\ 0 & 1 & 4 & 1 & 0 \\ 0 & 0 & 1 & 4 & 1 \\ 0 & 0 & 0 & 2 & 7 \end{pmatrix} \begin{pmatrix} H_{1,0} \\ H_{1,1} \\ H_{1,2} \\ H_{1,3} \\ H_{1,4} \end{pmatrix} = \begin{pmatrix} A_0 + 2A_1 \\ 4A_1 + 2A_2 \\ 4A_2 + 2A_3 \\ 4A_3 + 2A_4 \\ 8A_4 + A_5 \end{pmatrix} which will be expressed as :math:`TH_1 = D`. :math:`T` is a tridiagonal matrix, so the system can be solved in :math:`O(N)` operations. Here we shall use Thomas' algorithm or the tridiagonal matrix algorithm. .. seealso:: `Tridiagonal matrix algorithm. Wikipedia. `_ Define: * :math:`a = [a_0, \ a_1, \ ..., \ a_{N-2}]` as :math:`T`'s lower diagonal of :math:`N-1` elements, such that :math:`a_0 = a_1 = ... = a_{N-3} = 1`, and :math:`a_{N-2} = 2`; * :math:`b = [b_0, \ b_1, \ ..., \ b_{N-2}, \ b_{N-1}]` as :math:`T`'s main diagonal of :math:`N` elements, such that :math:`b_0 = 2`, :math:`b_1 = b_2 = ... = b_{N-2} = 4`, and :math:`b_{N-1} = 7`; * :math:`c = [c_0, \ c_1, \ ..., \ c_{N-2}]` as :math:`T`'s upper diagonal of :math:`{N-1}` elements, such that :math:`c_0 = c_1 = ... = c_{N-2} = 1`: this diagonal is filled with ones. If, according to Thomas' algorithm, we define: .. math:: c'_0 &= \frac{c_0}{b_0} & \\ c'_i &= \frac{c_i}{b_i - a_{i-1} c'_{i-1}}, & \quad \forall i \in \{1, ..., N-2\} \\ & & \\ D'_0 &= \frac{1}{b_0} D_0 & \\ D'_i &= \frac{1}{b_i - a_{i-1} c'{i-1}} (D_i - a_{i-1} D'_{i-1}), & \quad \forall i \in \{1, ..., N-1\} Then: .. math:: c'_0 &= 0.5 & \\ c'_i &= \frac{1}{4 - c'_{i-1}}, & \quad \forall i \in \{1, ..., N-2\} \\ & & \\ D'_0 &= 0.5A_0 + A_1 & \\ D'_i &= \frac{1}{4 - c'_{i-1}} (4A_i + 2A_{i+1} - D'_{i-1}) & \\ &= c_i (4A_i + 2A_{i+1} - D'_{i-1}), & \quad \forall i \in \{1, ..., N-2\} \\ D'_{N-1} &= \frac{1}{7 - 2c'_{N-2}} (8A_{N-1} + A_N - 2D'_{N-2}) & Finally, we can do Backward Substitution to find :math:`H_1`: .. math:: H_{1, N-1} &= D'_{N-1} & \\ H_{1, i} &= D'_i - c'_i H_{1, i+1}, & \quad \forall i \in \{0, ..., N-2\} Once we have :math:`H_1`, we can get :math:`H_2` (the array of second handles) as follows: .. math:: H_{2, i} &= 2A_{i+1} - H_{1, i+1}, & \quad \forall i \in \{0, ..., N-2\} \\ H_{2, N-1} &= 0.5A_N + 0.5H_{1, N-1} & As the matrix :math:`T` always follows the same pattern, we can define a memo list for :math:`c'` to avoid recalculation. We cannot do the same for :math:`D`, however, because it is always a different matrix. Parameters ---------- anchors Anchors of an open cubic spline. Returns ------- :class:`tuple` [:class:`~.Point3D_Array`, :class:`~.Point3D_Array`] A tuple of two arrays: one containing the 1st handle for every curve in the open cubic spline, and the other containing the 2nd handles. rr3Nr|rr?rK)r8r]rT CP_OPEN_MEMOrrSrV) rrrrrNrrrYrrrrs r,rr7sUd 7A  QA '!*C H!a% Xa!e__$9H9 xQ'' ( (ARAY'BqEE 'AE' " 1c(  B !A$J1 BqE aAE l Q1Q3Z 'C 1a!e__111QUbQi/01a!bQi-'(Q1q5\AaD-@1r!a%y=-PQBq1uI B 1q5"b ! !**111q5 ))1 1c(  B!A#JAaC(Bq1q5yMqtbQi'(Bq1uI r6Mr-a0r h0h1a1r#cdSr)r*rrrrs r,$get_quadratic_approximation_of_cubicrs cr-r"cdSr)r*rs r,rrs #r-r6%QuadraticSpline | QuadraticBezierPathc<tj|}tj|}tj|}tj|}td||||fDrd|jd} }n7td||||fDr |j\}} nt ddd|z|zz} dd|z|zz} d| | zz} tjd |z| f} || dd d <| | dd d <| | d d d <| | dd d <| | d d d <|| d d d <| S)uIf ``a0``, ``h0``, ``h1`` and ``a1`` are the control points of a cubic Bézier curve, approximate the curve with two quadratic Bézier curves and return an array of 6 points, where the first 3 points represent the first quadratic curve and the last 3 represent the second one. Otherwise, if ``a0``, ``h0``, ``h1`` and ``a1`` are _arrays_ of :math:`N` points representing :math:`N` cubic Bézier curves, return an array of :math:`6N` points where each group of :math:`6` consecutive points approximates each of the :math:`N` curves in a similar way as above. .. note:: If the cubic spline given by the original cubic Bézier curves is smooth, this algorithm will generate a quadratic spline which is also smooth. If a cubic Bézier is given by .. math:: C(t) = (1-t)^3 A_0 + 3(1-t)^2 t H_0 + 3(1-t)t^2 H_1 + t^3 A_1 where :math:`A_0`, :math:`H_0`, :math:`H_1` and :math:`A_1` are its control points, then this algorithm should generate two quadratic Béziers given by .. math:: Q_0(t) &= (1-t)^2 A_0 + 2(1-t)t M_0 + t^2 K \\ Q_1(t) &= (1-t)^2 K + 2(1-t)t M_1 + t^2 A_1 where :math:`M_0` and :math:`M_1` are the respective handles to be found for both curves, and :math:`K` is the end anchor of the 1st curve and the start anchor of the 2nd, which must also be found. To solve for :math:`M_0`, :math:`M_1` and :math:`K`, three conditions can be imposed: 1. :math:`Q_0'(0) = \frac{1}{2}C'(0)`. The derivative of the first quadratic curve at :math:`t = 0` should be proportional to that of the original cubic curve, also at :math:`t = 0`. Because the cubic curve is split into two parts, it is necessary to divide this by two: the speed of a point travelling through the curve should be half of the original. This gives: .. math:: Q_0'(0) &= \frac{1}{2}C'(0) \\ 2(M_0 - A_0) &= \frac{3}{2}(H_0 - A_0) \\ 2M_0 - 2A_0 &= \frac{3}{2}H_0 - \frac{3}{2}A_0 \\ 2M_0 &= \frac{3}{2}H_0 + \frac{1}{2}A_0 \\ M_0 &= \frac{1}{4}(3H_0 + A_0) 2. :math:`Q_1'(1) = \frac{1}{2}C'(1)`. The derivative of the second quadratic curve at :math:`t = 1` should be half of that of the original cubic curve for the same reasons as above, also at :math:`t = 1`. This gives: .. math:: Q_1'(1) &= \frac{1}{2}C'(1) \\ 2(A_1 - M_1) &= \frac{3}{2}(A_1 - H_1) \\ 2A_1 - 2M_1 &= \frac{3}{2}A_1 - \frac{3}{2}H_1 \\ -2M_1 &= -\frac{1}{2}A_1 - \frac{3}{2}H_1 \\ M_1 &= \frac{1}{4}(3H_1 + A_1) 3. :math:`Q_0'(1) = Q_1'(0)`. The derivatives of both quadratic curves should match at the point :math:`K`, in order for the final spline to be smooth. This gives: .. math:: Q_0'(1) &= Q_1'(0) \\ 2(K - M_0) &= 2(M_1 - K) \\ 2K - 2M_0 &= 2M_1 - 2K \\ 4K &= 2M_0 + 2M_1 \\ K &= \frac{1}{2}(M_0 + M_1) This is sufficient to find proper control points for the quadratic Bézier curves. Parameters ---------- a0 The start anchor of a single cubic Bézier curve, or an array of :math:`N` start anchors for :math:`N` curves. h0 The first handle of a single cubic Bézier curve, or an array of :math:`N` first handles for :math:`N` curves. h1 The second handle of a single cubic Bézier curve, or an array of :math:`N` second handles for :math:`N` curves. a1 The end anchor of a single cubic Bézier curve, or an array of :math:`N` end anchors for :math:`N` curves. Returns ------- result An array containing either 6 points for 2 quadratic Bézier curves approximating the original cubic curve, or :math:`6N` points for :math:`2N` quadratic curves approximating :math:`N` cubic curves. Raises ------ ValueError If ``a0``, ``h0``, ``h1`` and ``a1`` have different dimensions, or if their number of dimensions is not 1 or 2. c3,K|]}|jdkVdS)r3NndimrMres r, z7get_quadratic_approximation_of_cubic..Qs( 9 9S38q= 9 9 9 9 9 9r-r3rc3,K|]}|jdkVdS)r?Nrrs r,rz7get_quadratic_approximation_of_cubic..Ss( ; ;sSX] ; ; ; ; ; ;r-z/All arguments must be Point3D or Point3D_Array.g?rErNr?r|)r8r]allrT ValueErrorrS)rrrra0ch0ch1ca1c num_curvesrNm0m1kresults r,rrs`Z *R..C *R..C *R..C *R..C 9 9S#sC$8 9 9 999LSYq\C ; ;sCc&: ; ; ; ; ;L) CCJKKK S3 B S3 B rBwA Xq:~s+ , ,FF14a4LF14a4LF14a4LF14a4LF14a4LF14a4L Mr-boolcL|d|d}}d}d}|||zz}t|d|dz |dkrdSt|d|dz |dkrdStt|d|dz |dkS)aFReturns ``True`` if the spline given by ``points`` is closed, by checking if its first and last points are close to each other, or``False`` otherwise. .. note:: This function reimplements :meth:`np.allclose`, because repeated calling of :meth:`np.allclose` for only 2 points is inefficient. Parameters ---------- points An array of points defining a spline. Returns ------- :class:`bool` Whether the first and last points of the array are close enough or not to be considered the same, thus considering the defined spline as closed. Examples -------- .. code-block:: pycon >>> import numpy as np >>> from manim import is_closed >>> is_closed( ... np.array( ... [ ... [0, 0, 0], ... [1, 2, 3], ... [3, 2, 1], ... [0, 0, 0], ... ] ... ) ... ) True >>> is_closed( ... np.array( ... [ ... [0, 0, 0], ... [1, 2, 3], ... [3, 2, 1], ... [1e-10, 1e-10, 1e-10], ... ] ... ) ... ) True >>> is_closed( ... np.array( ... [ ... [0, 0, 0], ... [1, 2, 3], ... [3, 2, 1], ... [1e-2, 1e-2, 1e-2], ... ] ... ) ... ) False rrKgh㈵>g:0yE>Fr3r?)absr)r%rrrtolatol tolerances r,rrfs|F2J3E D Dte|#I 3q6E!H  ! ,,u 3q6E!H  ! ,,u CFU1X%&&)A,6 7 77r-ư>pointcontrol_pointsround_toc btfd|Dstdd|dtj|}t |dz }g}t D]\}}|dd|f}g}t |ddD]} t|| } g} d} t | ddD]E} t| | | z}||| z}| dkr||z}| || dz} F|| ttj| ztd |Drtj |ddd}| }t |dkr7tj |ttjd|z }||d |D}t!tj|}tjd |D}|S) aObtains the proportion along the bezier curve corresponding to a given point given the bezier curve's control points. The bezier polynomial is constructed using the coordinates of the given point as well as the bezier curve's control points. On solving the polynomial for each dimension, if there are roots common to every dimension, those roots give the proportion along the curve the point is at. If there are no real roots, the point does not lie on the curve. Parameters ---------- point The Cartesian Coordinates of the point whose parameter should be obtained. control_points The Cartesian Coordinates of the ordered control points of the bezier curve on which the point may or may not lie. round_to A float whose number of decimal places all values such as coordinates of points will be rounded. Returns ------- np.ndarray[float] List containing possible parameters (the proportions along the bezier curve) for the given point on the given bezier curve. This usually only contains one or zero elements, but if the point is, say, at the beginning/end of a closed loop, may return a list with more than 1 value, corresponding to the beginning and end etc. of the loop. Raises ------ :class:`ValueError` When ``point`` and the control points have different shapes. c3lK|].}tjtj|kV/dSr))r8rT)rMc_prs r,rz;proportions_along_bezier_curve_for_point..s8JJCrx"(3--/JJJJJJr-zPoint z and Control Points z have different shapes.r3NrKrc3"K|] }|dkV dS)rNr*)rMterms r,rz;proportions_along_bezier_curve_for_point..s&++Ttqy++++++r-c&g|]}d|DS)c(g|]}|jdk |S)r)imag)rMroots r,rOzGproportions_along_bezier_curve_for_point...s : : :t49>>d>>>r-r*)rMrootlists r,rOz.s' Q Q Qx : :x : : : Q Q Qr-cFg|]}d|jcxkrdknn|jS)rr3)real)rMrs r,rOz.s=CCCA!qv2B2B2B2B2B2B2B2B2B2B2B2Br-)rrr8rdlen enumeraterVrappendsum polynomial Polynomialrootsaroundrlog10r intersect1dr])rrrnr$rNcoordcontrol_coordsterms term_power outercoeffrsign subterm_num innercoeffsubtermbezier_polynom polynom_rootsrs` r,rrseX JJJJ>JJJ J J  WU W W W W W   Xn--N NaA E&&$$ U'3/2r** ; ;J:..JDD$ZR88   #J <>&,,.. }   ! !ImS!h,9O9O5P5PQQM ]#### Q Q5 Q Q QE 2>5 ) )E ZCCCCC D DF Mr-cJt|||}t|dkS)aChecks if a given point lies on the bezier curves with the given control points. This is done by solving the bezier polynomial with the point as the constant term; if any real roots exist, the point lies on the bezier curve. Parameters ---------- point The Cartesian Coordinates of the point to check. control_points The Cartesian Coordinates of the ordered control points of the bezier curve on which the point may or may not lie. round_to A float whose number of decimal places all values such as coordinates of points will be rounded. Returns ------- bool Whether the point lies on the curve. r)rr)rrrr$s r,rrs%6 5UNH U UE u::>r-)r%rr&r')r%r.r&r/)r%r1r&r/)r%rr^r_r`r_r&r)r%rr4r_r&r$)r~rrrr&r)r%rrrr&r$)rrrrr&r)rr_rr_rr_r&r_)rr_rr_rrr&r)rrrrrr_r&r)rrrrrrr&r)rrrrrr5r&r)rr_rr_rr_r&r)rr_rr_r&r_)rrrrr&r)rrrrr&r)rr_rr_rr_r&r_)rr_rr_rrr&r)rrrrrrr&r)rrrrrrr&r) rr_rr_rr_rr_rr_r&r_) rr_rr_rr_rr_rrr&r) rr_rr_rr_rr_rrr&r)rr!r&r) rr rr rr rr r&r#) rr!rr!rr!rr!r&r") rr6rr6rr6rr6r&r)r%rr&r)r )rr rrrr_r&r)rr rrrr_r&r)7__doc__ __future__r__all__collections.abcrr functoolsrtypingrrnumpyr8manim.utils.simple_functionsr manim.typingrrrrrrrrr r!r"r#r$rrrrVr}__annotations__rrrr r r r r rrdrrrrrrrrrr*r-r,r?s222""""""   $/.......********//////( AAA A  777 7 rrrrjVVVVrw#w#w#w#v 3I2HuuQxx2H2H2HHHHHjjjjZ~1~1~1~1B8888| EEE E MMM M KKK K UUU U - - - -F))))X /// / 555 5" MMM M QQQ Q UUU U&6&6&6&6R    ''''V(C(C(C(CV5'""5'""^^^^B rx VVVVr     DDDDNF8F8F8F8XSSSSSrr-