ó
    {ñ:iiJ  ã                   óþ   • S r SSKJr  SSKrSSKrSSKrSSKJr  \R                  \" SS9S 5       5       r
 " S S	\5      rS
 rS rS rS r SS jr " S S5      r SS jrSS jrS rS rSS jrS rS rSS jrg)uP   
A module providing some utility functions regarding BÃ©zier path manipulation.
é    )Ú	lru_cacheN)Ú_apié€   )Úmaxsizec                 óÂ   • X:”  a  g[        XU-
  5      n[        R                  " SUS-   5      n[        R                  " U S-   U-
  U-  5      R	                  [
        5      $ )Nr   é   )ÚminÚnpÚarangeÚprodÚastypeÚint)ÚnÚkÚis      ÚT/srv/projetos/modelo_ml_acdoc/venv/lib/python3.13/site-packages/matplotlib/bezier.pyÚ_combr      sS   € ð 	ƒuØÜˆA�1‰u‹€AÜ
�	Š	�!�Q˜‘UÓ€AÜ�7Š7�A˜‘E˜A‘I˜q‘=Ó!×(Ñ(¬Ó-Ð-ó    c                   ó   • \ rS rSrSrg)ÚNonIntersectingPathExceptioné   © N)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__static_attributes__r   r   r   r   r      s   † Úr   r   c                 óà   ^• X0-  X!-  -
  nXt-  Xe-  -
  n	X2* pºXv* pÜX­-  X¼-  -
  m[        T5      S:  a  [        S5      eXÛ* pþU* U
nnU4S jXïUU4 5       u  pïnnXè-  Xù-  -   nUU-  UU	-  -   nUU4$ )z‚
Return the intersection between the line through (*cx1*, *cy1*) at angle
*t1* and the line through (*cx2*, *cy2*) at angle *t2*.
gê-�™—q=zcGiven lines do not intersect. Please verify that the angles are not equal or differ by 180 degrees.c              3   ó,   >#   • U  H	  oT-  v •  M     g 7f)Nr   )Ú.0r   Úad_bcs     €r   Ú	<genexpr>Ú#get_intersection.<locals>.<genexpr>9   s   øé € Ð:Ò)9 A˜%–iÒ)9ùs   ƒ)ÚabsÚ
ValueError)Úcx1Úcy1Úcos_t1Úsin_t1Úcx2Úcy2Úcos_t2Úsin_t2Ú	line1_rhsÚ	line2_rhsÚaÚbÚcÚdÚa_Úb_Úc_Úd_ÚxÚyr!   s                       @r   Úget_intersectionr:       s³   ø€ ð ‘˜v™|Ñ+€IØ‘˜v™|Ñ+€Ið �7€qØ�7€qà‰E�A‘E‰M€EÜ
ˆ5ƒz�EÓÜð Nó Oð 	Oð �ˆØˆR�ˆ€BÜ:¨"°"°bÑ)9Ó:�N€BˆB�à
‰˜™Ñ'€AØ
ˆY‰˜˜i™Ñ'€Aàˆaˆ4€Kr   c                 ó`   • US:X  a  XX4$ X2* peU* Up‡XE-  U -   XF-  U-   p©XG-  U -   XH-  U-   pËXšX¼4$ )z§
For a line passing through (*cx*, *cy*) and having an angle *t*, return
locations of the two points located along its perpendicular line at the
distance of *length*.
ç        r   )ÚcxÚcyÚcos_tÚsin_tÚlengthr(   r)   r,   r-   Úx1Úy1Úx2Úy2s                r   Úget_normal_pointsrF   A   sY   € ð �ƒ|Ø�rˆ~Ðà˜FˆFØ�V˜UˆFà‰_˜rÑ! 6¡?°RÑ#7ˆØ‰_˜rÑ! 6¡?°RÑ#7ˆà�2ˆ>Ðr   c                 ó.   • U S S SU-
  -  U SS  U-  -   nU$ )Néÿÿÿÿr   r   )ÚbetaÚtÚ	next_betas      r   Ú_de_casteljau1rL   Z   s+   € Ø�S�b�	˜Q ™UÑ# d¨1¨2 h°¡lÑ2€IØÐr   c                 ó  • [         R                  " U 5      n U /n [        X5      n UR                  U 5        [	        U 5      S:X  a  OM.  U V s/ s H  o S   PM	     nn [        U5       V s/ s H  o S   PM	     nn X44$ s  sn f s  sn f )u‰   
Split a BÃ©zier segment defined by its control points *beta* into two
separate segments divided at *t* and return their control points.
r   r   rH   )r
   ÚasarrayrL   ÚappendÚlenÚreversed)rI   rJ   Ú	beta_listÚ	left_betaÚ
right_betas        r   Úsplit_de_casteljaurU   _   s�   € ô
 �:Š:�dÓ€DØ�€IØ
Ü˜dÓ&ˆØ×Ñ˜ÔÜˆt‹9˜‹>Øñ	 ñ
 &/Ó/¢Y˜T�a”¡Y€IÐ/Ü'/°	Ô':Ó;Ò':˜t�r”(Ñ':€JÐ;àÐ Ð ùò 0ùÚ;s   ÁA=Á*Bc                 óH  • U " U5      nU " U5      nU" U5      nU" U5      nXx:X  a  XV:w  a  [        S5      e [        R                  " US   US   -
  US   US   -
  5      U:  a  X#4$ SX#-   -  n	U " U	5      n
U" U
5      nX{-  (       a  U	nXj:X  a  X#4$ U
nOU	nXZ:X  a  X#4$ U
nUnMm  )u$  
Find the intersection of the BÃ©zier curve with a closed path.

The intersection point *t* is approximated by two parameters *t0*, *t1*
such that *t0* <= *t* <= *t1*.

Search starts from *t0* and *t1* and uses a simple bisecting algorithm
therefore one of the end points must be inside the path while the other
doesn't. The search stops when the distance of the points parametrized by
*t0* and *t1* gets smaller than the given *tolerance*.

Parameters
----------
bezier_point_at_t : callable
    A function returning x, y coordinates of the BÃ©zier at parameter *t*.
    It must have the signature::

        bezier_point_at_t(t: float) -> tuple[float, float]

inside_closedpath : callable
    A function returning True if a given point (x, y) is inside the
    closed path. It must have the signature::

        inside_closedpath(point: tuple[float, float]) -> bool

t0, t1 : float
    Start parameters for the search.

tolerance : float
    Maximal allowed distance between the final points.

Returns
-------
t0, t1 : float
    The BÃ©zier path parameters.
z3Both points are on the same side of the closed pathr   r   ç      à?)r   r
   Úhypot)Úbezier_point_at_tÚinside_closedpathÚt0Út1Ú	toleranceÚstartÚendÚstart_insideÚ
end_insideÚmiddle_tÚmiddleÚmiddle_insides               r   Ú*find_bezier_t_intersecting_with_closedpathre   q   så   € ñL ˜bÓ!€EÙ
˜BÓ
€Cá$ UÓ+€LÙ" 3Ó'€JàÓ! e£lÜ*ØAóCð 	Cð ô �8Š8�E˜!‘H˜s 1™vÑ% u¨Q¡x°#°a±&Ñ'8Ó9¸IÓEØ�6ˆMð ˜"™'‘?ˆÙ" 8Ó,ˆÙ)¨&Ó1ˆà×'ØˆBØ‹}ð �v�Ø‰CàˆBØ‹ð �v�ØˆEØ(ˆLñ3 r   c                   óp   • \ rS rSrSrS rS rS r\S 5       r	\S 5       r
\S 5       r\S	 5       rS
 rSrg)ÚBezierSegmenté½   u   
A d-dimensional BÃ©zier segment.

Parameters
----------
control_points : (N, d) array
    Location of the *N* control points.
c           	      ó,  • [         R                  " U5      U l        U R                  R                  u  U l        U l        [         R                  " U R                  5      U l        [        U R                  5       Vs/ s Hd  n[        R                  " U R                  S-
  5      [        R                  " U5      [        R                  " U R                  S-
  U-
  5      -  -  PMf     nnU R                  R                  U-  R                  U l        g s  snf )Nr   )r
   rN   Ú_cpointsÚshapeÚ_NÚ_dr   Ú_ordersÚrangeÚmathÚ	factorialÚTÚ_px)ÚselfÚcontrol_pointsr   Úcoeffs       r   Ú__init__ÚBezierSegment.__init__Ç   sÆ   € ÜŸ
š
 >Ó2ˆŒØŸ=™=×.Ñ.ÑˆŒ�”Ü—y’y §¡Ó)ˆŒô   §¡œ.ó*â(�Qô —’ §¡¨!¡Ó,Ü—^’^ AÓ&¬¯ª¸¿¹À!¹Àa¹Ó)HÑHôJá(ð 	ð *ð —M‘M—O‘O eÑ+×.Ñ.ˆ�ùò*s   Á;A+Dc                 ó  • [         R                  " U5      n[         R                  R                  SU-
  U R                  SSS2   5      [         R                  R                  XR                  5      -  U R
                  -  $ )uÙ   
Evaluate the BÃ©zier curve at point(s) *t* in [0, 1].

Parameters
----------
t : (k,) array-like
    Points at which to evaluate the curve.

Returns
-------
(k, d) array
    Value of the curve for each point in *t*.
r   NrH   )r
   rN   ÚpowerÚouterrn   rs   ©rt   rJ   s     r   Ú__call__ÚBezierSegment.__call__Ð   s^   € ô �JŠJ�q‹MˆÜ—‘—‘˜q 1™u d§l¡l±4°R°4Ñ&8Ó9Ü—(‘(—.‘. §L¡LÓ1ñ2Ø59·X±Xñ>ð 	>r   c                 ó$   • [        U " U5      5      $ )zH
Evaluate the curve at a single point, returning a tuple of *d* floats.
)Útupler|   s     r   Ú
point_at_tÚBezierSegment.point_at_tâ   s   € ô ‘T˜!“W‹~Ðr   c                 ó   • U R                   $ )z The control points of the curve.)rj   ©rt   s    r   ru   ÚBezierSegment.control_pointsè   s   € ð �}‰}Ðr   c                 ó   • U R                   $ )zThe dimension of the curve.)rm   r„   s    r   Ú	dimensionÚBezierSegment.dimensioní   s   € ð �w‰wˆr   c                 ó    • U R                   S-
  $ )z@Degree of the polynomial. One less the number of control points.r   )rl   r„   s    r   ÚdegreeÚBezierSegment.degreeò   s   € ð �w‰w˜‰{Ðr   c                 ó<  • U R                   nUS:”  a  [        R                  " S[        5        U R                  n[
        R                  " US-   5      SS2S4   n[
        R                  " US-   5      SSS24   nSXC-   -  [        X45      -  n[        X5      U-  U-  $ )u:  
The polynomial coefficients of the BÃ©zier curve.

.. warning:: Follows opposite convention from `numpy.polyval`.

Returns
-------
(n+1, d) array
    Coefficients after expanding in polynomial basis, where :math:`n`
    is the degree of the BÃ©zier curve and :math:`d` its dimension.
    These are the numbers (:math:`C_j`) such that the curve can be
    written :math:`\sum_{j=0}^n C_j t^j`.

Notes
-----
The coefficients are calculated as

.. math::

    {n \choose j} \sum_{i=0}^j (-1)^{i+j} {j \choose i} P_i

where :math:`P_i` are the control points of the curve.
é
   zFPolynomial coefficients formula unstable for high order Bezier curves!r   NrH   )rŠ   ÚwarningsÚwarnÚRuntimeWarningru   r
   r   r   )rt   r   ÚPÚjr   Ú	prefactors         r   Úpolynomial_coefficientsÚ%BezierSegment.polynomial_coefficients÷   s�   € ð2 �K‰Kˆàˆr‹6Ü�MŠMð 1Ü2@ôBà×ÑˆÜ�IŠI�a˜‘c‹Nš1˜d˜7Ñ#ˆÜ�IŠI�a˜‘c‹N˜4¢˜7Ñ#ˆØ˜1™5‘M¤E¨!£KÑ/ˆ	Ü�Q‹{˜YÑ&¨Ñ*Ð*r   c                 ó¢  • U R                   nUS::  a,  [        R                  " / 5      [        R                  " / 5      4$ U R                  n[        R                  " SUS-   5      SS2S4   USS -  n/ n/ n[        UR                  5       HW  u  pg[        R                  " USSS2   5      nUR                  U5        UR                  [        R                  " X†5      5        MY     [        R                  " U5      n[        R                  " U5      n[        R                  " U5      US:¬  -  US:*  -  n	XI   [        R                  " U5      U	   4$ )aƒ  
Return the dimension and location of the curve's interior extrema.

The extrema are the points along the curve where one of its partial
derivatives is zero.

Returns
-------
dims : array of int
    Index :math:`i` of the partial derivative which is zero at each
    interior extrema.
dzeros : array of float
    Of same size as dims. The :math:`t` such that :math:`d/dx_i B(t) =
    0`
r   NrH   r   )rŠ   r
   Úarrayr”   r   Ú	enumeraterr   ÚrootsrO   Ú	full_likeÚconcatenateÚisrealÚreal)
rt   r   ÚCjÚdCjÚdimsr™   r   ÚpiÚrÚin_ranges
             r   Úaxis_aligned_extremaÚ"BezierSegment.axis_aligned_extrema  s  € ð  �K‰KˆØ�‹6Ü—8’8˜B“<¤§¢¨"£Ð-Ð-Ø×)Ñ)ˆÜ�iŠi˜˜1˜Q™3Ó¢ 4 Ñ(¨2¨a¨b¨6Ñ1ˆØˆØˆÜ˜sŸu™uÖ%‰EˆAÜ—’˜™D˜b˜D™Ó"ˆAØ�L‰L˜ŒOØ�K‰KœŸš QÓ*Ö+ñ &ô —’˜uÓ%ˆÜ�~Š~˜dÓ#ˆÜ—9’9˜UÓ# u°¡zÑ2°e¸q±jÑAˆØ‰~œrŸwšw u›~¨hÑ7Ð7Ð7r   )rl   rj   rm   rn   rs   N)r   r   r   r   Ú__doc__rw   r}   r�   Úpropertyru   r‡   rŠ   r”   r¤   r   r   r   r   rg   rg   ½   sl   † ñò/ò>ò$ð ñó ðð ñó ðð ñó ðð ñ!+ó ð!+õF8r   rg   c                 ót   • [        U 5      nUR                  n[        XAUS9u  pV[        XU-   S-  5      u  pxXx4$ )u2  
Split a BÃ©zier curve into two at the intersection with a closed path.

Parameters
----------
bezier : (N, 2) array-like
    Control points of the BÃ©zier segment. See `.BezierSegment`.
inside_closedpath : callable
    A function returning True if a given point (x, y) is inside the
    closed path. See also `.find_bezier_t_intersecting_with_closedpath`.
tolerance : float
    The tolerance for the intersection. See also
    `.find_bezier_t_intersecting_with_closedpath`.

Returns
-------
left, right
    Lists of control points for the two BÃ©zier segments.
)r]   g       @)rg   r�   re   rU   )	ÚbezierrZ   r]   ÚbzrY   r[   r\   Ú_leftÚ_rights	            r   Ú)split_bezier_intersecting_with_closedpathr­   <  sH   € ô, 
�vÓ	€BØŸ™Ðä7Ø¸	ñC�F€Bô ' v°R±¸2©~Ó>�M€EØˆ=Ðr   c           	      ór  • SSK Jn  U R                  5       n[        U5      u  pgU" USS 5      nUn	Sn
SnU HF  u  pgUn
U[	        U5      S-  -  nU" USS 5      U:w  a  [
        R                  " U	SS U/5      n  OUn	MH     [        S5      eUR                  S5      n[        XÑU5      u  pï[	        U5      S:X  a&  UR                  /nUR                  UR                  /nO·[	        U5      S	:X  a<  UR                  UR                  /nUR                  UR                  UR                  /nOl[	        U5      S
:X  aR  UR                  UR                  UR                  /nUR                  UR                  UR                  UR                  /nO[        S5      eUSS nUSS nU R                  cW  U" [
        R                  " U R                   SU U/5      5      nU" [
        R                  " UU R                   US /5      5      nOžU" [
        R                  " U R                   SU
 U/5      [
        R                  " U R                  SU
 U/5      5      nU" [
        R                  " UU R                   US /5      [
        R                  " UU R                  US /5      5      nU(       a  U(       d  UUnnUU4$ )zT
Divide a path into two segments at the point where ``inside(x, y)`` becomes
False.
r   )ÚPathéþÿÿÿNr   é   z*The path does not intersect with the patch)rH   r±   é   é   zThis should never be reached)Úpathr¯   Úiter_segmentsÚnextrP   r
   r›   r%   Úreshaper­   ÚLINETOÚMOVETOÚCURVE3ÚCURVE4ÚAssertionErrorÚcodesÚvertices)r´   Úinsider]   Úreorder_inoutr¯   Ú	path_iterÚ
ctl_pointsÚcommandÚbegin_insideÚctl_points_oldÚioldr   Úbezier_pathÚbpÚleftÚrightÚ
codes_leftÚcodes_rightÚ
verts_leftÚverts_rightÚpath_inÚpath_outs                         r   Úsplit_path_inoutrÑ   _  sy  € õ
 Ø×"Ñ"Ó$€Iä˜y›/Ñ€JÙ˜* R S˜/Ó*€Là€Nà€DØ	€Aã(Ñˆ
ØˆØ	ŒS�‹_ Ñ!Ñ!ˆÙ�*˜R˜S�/Ó" lÓ2ÜŸ.š.¨.¸¸Ð*=¸zÐ)JÓKˆKÙØ#Šñ  )ô ÐEÓFÐFà	×	Ñ	˜WÓ	%€BÜ;Ø
�Ió�K€Dä
ˆ4ƒy�Aƒ~Ø—k‘k�]ˆ
Ø—{‘{ D§K¡KÐ0‰Ü	ˆT‹�a‹Ø—k‘k 4§;¡;Ð/ˆ
Ø—{‘{ D§K¡K°·±Ð=‰Ü	ˆT‹�a‹Ø—k‘k 4§;¡;°·±Ð<ˆ
Ø—{‘{ D§K¡K°·±¸d¿k¹kÐJ‰äÐ;Ó<Ð<à�a�b�€JØ™�(€Kà‡z�zÑÙ”r—~’~ t§}¡}°R°aÐ'8¸*Ð&EÓFÓGˆÙœŸš¨°T·]±]À1À2Ð5FÐ'GÓHÓI‰ñ ”r—~’~ t§}¡}°U°dÐ';¸ZÐ&HÓIÜ—~’~ t§z¡z°%°4Ð'8¸*Ð&EÓFóHˆñ œŸš¨°T·]±]À1À2Ð5FÐ'GÓHÜŸš¨°T·Z±ZÀÀ°^Ð'DÓEóGˆö ž\Ø$ g�ˆà�HÐÐr   c                 ó&   ^ ^^• US-  mU UU4S jnU$ )zº
Return a function that checks whether a point is in a circle with center
(*cx*, *cy*) and radius *r*.

The returned function has the signature::

    f(xy: tuple[float, float]) -> bool
r±   c                 ó4   >• U u  pUT-
  S-  UT-
  S-  -   T:  $ )Nr±   r   )Úxyr8   r9   r=   r>   Úr2s      €€€r   Ú_fÚinside_circle.<locals>._f§  s*   ø€ Ø‰ˆØ�B‘˜1‰}  B¡¨1™}Ñ,¨rÑ1Ð1r   r   )r=   r>   r¢   rÖ   rÕ   s   ``  @r   Úinside_circlerØ   œ  s   ú€ ð 
ˆa‰€B÷2ð €Ir   c                 óF   • X -
  X1-
  pTXD-  XU-  -   S-  nUS:X  a  gXF-  XV-  4$ )NrW   r   )r<   r<   r   )Úx0Úy0rB   rC   ÚdxÚdyr3   s          r   Úget_cos_sinrÞ   ¯  s8   € Ø‰W�b‘gˆØ	‰�2‘7Ñ	˜rÑ!€AàˆAƒvØØ‰6�2‘6ˆ>Ðr   c                 óÄ   • [         R                  " X5      n[         R                  " X#5      n[        XV-
  5      nXt:  a  g[        U[         R                  -
  5      U:  a  gg)a�  
Check if two lines are parallel.

Parameters
----------
dx1, dy1, dx2, dy2 : float
    The gradients *dy*/*dx* of the two lines.
tolerance : float
    The angular tolerance in radians up to which the lines are considered
    parallel.

Returns
-------
is_parallel
    - 1 if two lines are parallel in same direction.
    - -1 if two lines are parallel in opposite direction.
    - False otherwise.
r   rH   F)r
   Úarctan2r$   r¡   )Údx1Údy1Údx2Údy2r]   Útheta1Útheta2Údthetas           r   Úcheck_if_parallelrè   ¸  sP   € ô& �ZŠZ˜Ó!€FÜ�ZŠZ˜Ó!€FÜ�‘Ó!€FØÓØÜ	ˆV”b—e‘e‰^Ó	˜yÓ	(Øàr   c           
      ó  • U S   u  p#U S   u  pEU S   u  pg[        X$-
  X5-
  XF-
  XW-
  5      nUS:X  a'  [        R                  " S5        [        X#Xg5      u  pšXšpËO[        X#XE5      u  pš[        XEXg5      u  p¼[	        X#XšU5      u  pÞnn[	        XgX¼U5      u  nnnn [        XÞU	U
UUX¼5      u  nn[        UUU	U
UUX¼5      u  nnXÞ4UU4UU4/nUU4UU4UU4/nUU4$ ! [         a#    SUU-   -  SUU-   -  nnSUU-   -  SUU-   -  nn NEf = f)u�   
Given the quadratic BÃ©zier control points *bezier2*, returns
control points of quadratic BÃ©zier lines roughly parallel to given
one separated by *width*.
r   r   r±   rH   z8Lines do not intersect. A straight line is used instead.rW   )rè   r   Úwarn_externalrÞ   rF   r:   r%   )Úbezier2ÚwidthÚc1xÚc1yÚcmxÚcmyÚc2xÚc2yÚparallel_testr(   r)   r,   r-   Úc1x_leftÚc1y_leftÚ	c1x_rightÚ	c1y_rightÚc2x_leftÚc2y_leftÚ	c2x_rightÚ	c2y_rightÚcmx_leftÚcmy_leftÚ	cmx_rightÚ	cmy_rightÚ	path_leftÚ
path_rights                              r   Úget_parallelsr  Ö  s©  € ð �q‰z�H€CØ�q‰z�H€CØ�q‰z�H€Cä% c¡i°±Ø&)¡i°±ó<€Mð ˜ÓÜ×ÒØFô	Hä$ S¨sÓ8‰ˆØ‘ô % S¨sÓ8‰ˆÜ$ S¨sÓ8‰ˆô 	˜# F°EÓ:ñ -€H˜	 9ô 	˜# F°EÓ:ñ -€Hˆh˜	 9ð
Ü-¨hÀ&Ø.4°hÀØ.4ó>Ñˆ�(ô  0°	¸9ÀfØ06¸	À9Ø06ó @Ñˆ	�9ð  Ð%Ø˜HÐ%Ø˜HÐ%ð'€Ið ˜iÐ(Ø˜iÐ(Ø˜iÐ(ð*€Jð �jÐ Ð øô) ó 	
ð
 �8˜hÑ&Ñ'¨°¸8Ñ0CÑ)Dð ˆð �9˜yÑ(Ñ)¨3°)¸iÑ2GÑ+Hð ˆ	‘9ð	
ús   Â'C Ã*DÄDc                 óF   • SSU-  X-   -
  -  nSSU-  X-   -
  -  nX4Xg4XE4/$ )u’   
Find control points of the BÃ©zier curve passing through (*c1x*, *c1y*),
(*mmx*, *mmy*), and (*c2x*, *c2y*), at parametric values 0, 0.5, and 1.
rW   r³   r   )rí   rî   ÚmmxÚmmyrñ   rò   rï   rð   s           r   Úfind_control_pointsr     sA   € ð
 ��C‘˜3™9Ñ%Ñ
&€CØ
��C‘˜3™9Ñ%Ñ
&€CØˆJ˜˜
 S JÐ/Ð/r   c                 ó¢  • U S   u  pVU S   u  pxU S   u  pš[        XVXx5      u  p¼[        XxXš5      u  pÞ[        XVX¼X-  5      u  nnnn[        XšXÞX-  5      u  nnnnXW-   S-  Xh-   S-  nnXy-   S-  XŠ-   S-  nnUU-   S-  UU-   S-  nn[        UUUU5      u  nn[        UUUUX-  5      u  nn n!n"[        UUUU UU5      n#[        UUU!U"UU5      n$U#U$4$ )uœ   
Being similar to `get_parallels`, returns control points of two quadratic
BÃ©zier lines having a width roughly parallel to given one separated by
*width*.
r   r   r±   rW   )rÞ   rF   r  )%rë   rì   Úw1ÚwmÚw2rí   rî   rï   rð   Úc3xÚc3yr(   r)   r,   r-   rô   rõ   rö   r÷   Úc3x_leftÚc3y_leftÚ	c3x_rightÚ	c3y_rightÚc12xÚc12yÚc23xÚc23yÚc123xÚc123yÚcos_t123Úsin_t123Ú
c123x_leftÚ
c123y_leftÚc123x_rightÚc123y_rightr   r  s%                                        r   Úmake_wedged_bezier2r  *  sA  € ð �q‰z�H€CØ�q‰z�H€CØ�q‰z�H€Cô ! ¨3Ó4�N€FÜ  ¨3Ó4�N€Fô 	˜# F°E±JÓ?ñ -€Hˆh˜	 9ô 	˜# F°E±JÓ?ñ -€Hˆh˜	 9ð ‘)˜rÑ! C¡I°Ñ#3ˆ$€DØ‘)˜rÑ! C¡I°Ñ#3ˆ$€DØ˜4‘K 2Ñ%¨¨t©°rÑ'9ˆ5€Eô % T¨4°°tÓ<Ñ€Hˆhô 	˜% ¨°(¸E¹JÓGñ 5€J�
˜K¨ô $ H¨hØ$.°
Ø$,¨hó8€Iô % Y°	Ø%0°+Ø%.°	ó;€Jð �jÐ Ð r   )r<   ç      ð?ç{®Gáz„?)r  )r  F)gñhãˆµøä>)r  rW   r<   )r¦   Ú	functoolsr   rp   rŽ   Únumpyr
   Ú
matplotlibr   Ú	vectorizer   r%   r   r:   rF   rL   rU   re   rg   r­   rÑ   rØ   rÞ   rè   r  r  r  r   r   r   Ú<module>r$     s­   ðñõ  Û Û ã å ð ‡�Ù
�3Ññ.ó ó ð.ô	 :ô 	òòBò2ò
!ð& GKôI)÷X|8ñ |8ð@ .2ôôF:òzò&ôò<G!òT0õ0!r   