Ë
    £èh^$  ã                  ó˜   — d dl mZ d dlmZmZ d dlmZ d dlZd dlZ	d dl
mZmZmZmZ dgZ	  G d„ d«      Zdd„Z ed¬	«      dd
„«       Zy)é    )Úannotations)ÚIterableÚSequence)Ú	lru_cacheN)ÚVec3ÚNULLVECÚMatrix44ÚUVecÚBezierc                  ó~   — e Zd ZdZdd„Zedd„«       Zddd„Zddd„Zdd„Z	dd„Z
dd„Zdd	„Z	 	 	 	 dd
„Zdd„Zdd„Zy)r   uC  Generic `BÃ©zier curve`_ of any degree.

    A `BÃ©zier curve`_ is a parametric curve used in computer graphics and
    related fields. BÃ©zier curves are used to model smooth curves that can be
    scaled indefinitely. "Paths", as they are commonly referred to in image
    manipulation programs, are combinations of linked BÃ©zier curves.
    Paths are not bound by the limits of rasterized images and are intuitive to
    modify. (Source: Wikipedia)

    This is a generic implementation which works with any count of definition
    points greater than 2, but it is a simple and slow implementation. For more
    performance look at the specialized :class:`Bezier4P` and :class:`Bezier3P`
    classes.

    Objects are immutable.

    Args:
        defpoints: iterable of definition points as :class:`Vec3` compatible objects.

    c                ó8   — t        j                  |«      | _        y ©N)r   ÚtupleÚ
_defpoints)ÚselfÚ	defpointss     ú1lib/python3.12/site-packages/ezdxf/math/bezier.pyÚ__init__zBezier.__init__b   s   € Ü*.¯*©*°YÓ*?ˆ�ó    c                ó   — | j                   S )z1Control points as tuple of :class:`Vec3` objects.)r   ©r   s    r   Úcontrol_pointszBezier.control_pointse   s   € ð �‰Ðr   c                óB   — | j                  | j                  |«      «      S )zhApproximates curve by vertices as :class:`Vec3` objects, vertices
        count = segments + 1.
        )ÚpointsÚparams©r   Úsegmentss     r   ÚapproximatezBezier.approximatej   s   € ð �{‰{˜4Ÿ;™; xÓ0Ó1Ð1r   c              #  ó  ‡ ‡‡K  — dˆˆ ˆfd„Šd|z  }d}‰ j                   d   }|–— |dk  r\||z   }t        j                  |d«      r‰ j                   d   }d}n‰ j                  |«      } ‰||||«      E d{  –—†  |}|}|dk  rŒ[yy7 Œ­w)a8  Adaptive recursive flattening. The argument `segments` is the
        minimum count of approximation segments, if the distance from the center
        of the approximation segment to the curve is bigger than `distance` the
        segment will be subdivided.

        Args:
            distance: maximum distance from the center of the curve (Cn)
                to the center of the linear (C1) curve between two
                approximation points to determine if a segment should be
                subdivided.
            segments: minimum segment count

        c              3  óè   •K  — ||z   dz  }‰j                  |«      }| j                  |«      }|j                  |«      ‰k  r|–— y  ‰	| |||«      E d {  –—†   ‰	||||«      E d {  –—†  y 7 Œ7 Œ­w)Ng      à?)ÚpointÚlerpÚdistance)
Ústart_pointÚ	end_pointÚstart_tÚend_tÚmid_tÚ	mid_pointÚ	chk_pointr#   r   Úsubdivs
          €€€r   r+   z!Bezier.flattening.<locals>.subdiv   s   øè ø€ Ø˜u‘_¨Ñ+ˆEØŸ
™
 5Ó)ˆIØ#×(Ñ(¨Ó3ˆIð ×!Ñ! )Ó,¨xÒ7Ø“á! +¨y¸'À5ÓI×IÐIÙ! )¨Y¸¸uÓE×EÑEð JøØEús$   ƒAA2ÁA.ÁA2Á(A0Á)A2Á0A2ç      ð?ç        r   éÿÿÿÿN)r&   Úfloatr'   r/   )r   ÚmathÚiscloser!   )	r   r#   r   ÚdtÚt0r$   Út1r%   r+   s	   ``      @r   Ú
flatteningzBezier.flatteningp   s›   úè ø€ ÷
	Fð �8‰^ˆØˆØ—o‘o aÑ(ˆØÒØ�3ŠhØ�b‘ˆBÜ�|‰|˜B Ô$Ø ŸO™O¨BÑ/�	Ø‘à ŸJ™J r›N�	Ù˜k¨9°b¸"Ó=×=Ð=ØˆBØ#ˆKð �3�hð >ús   …A4BÁ9B
Á:BÂBc              #  óT   K  — t        j                  dd|dz   «      E d{  –—†  y7 Œ­w)zCYield evenly spaced parameters from 0 to 1 for given segment count.r-   r,   é   N)ÚnpÚlinspacer   s     r   r   zBezier.paramsš   s    è ø€ ä—;‘;˜s C¨°A©Ó6×6Ò6ús   ‚( &¡(c                óÐ   — |dk  s|dkD  rt        d«      ‚d|z
  dk  rd}t        }| j                  }t        |«      }t	        |«      D ]  }|t        |dz
  ||«      ||   z  z  }Œ |S )z[Returns a point for parameter `t` in range [0, 1] as :class:`Vec3`
        object.
        r-   r,   úParameter t not in range [0, 1]çñhãˆµøÔ>r7   )Ú
ValueErrorr   r   ÚlenÚrangeÚbernstein_basis)r   Útr!   ÚptsÚnÚis         r   r!   zBezier.pointž   sx   € ð ˆsŠ7�a˜#’gÜÐ>Ó?Ð?Ø�!‰G�tÒØˆAÜˆØ�o‰oˆÜ�‹Hˆä�q–ˆAØ”_ Q¨¡U¨A¨qÓ1°C¸±FÑ:Ñ:‰Eð àˆr   c              #  ó@   K  — |D ]  }| j                  |«      –— Œ y­w)z…Yields multiple points for parameters in vector `t` as :class:`Vec3`
        objects. Parameters have to be in range [0, 1].
        N)r!   ©r   rA   Úus      r   r   zBezier.points®   s    è ø€ ó ˆAØ—*‘*˜Q“-Óñ ùó   ‚c                ó|  — |dk  s|dkD  rt        d«      ‚d|z
  dk  rd}| j                  }t        |«      }|dz
  }t        }t        }t        }||z  }|dz
  }	|dk(  r(||d   |d   z
  z  }||	z  |d   d|d   z  z
  |d   z   z  }t	        |«      D ]¦  }
t        ||
|«      }||||
   z  z  }d|cxk  rdk  rPn nMd|z
  }|
||z  z
  }||||z  z  |z  ||
   z  z  }|||z  ||z  z
  |
dd|z  z
  z  z
  ||z  |z  z  |z  ||
   z  z  }|dk(  sŒ||||   ||	   z
  z  }||	z  ||   d||	   z  z
  ||dz
     z   z  }Œ¨ |||fS )	z‚Returns (point, 1st derivative, 2nd derivative) tuple for parameter `t`
        in range [0, 1] as :class:`Vec3` objects.
        r-   r,   r;   r<   r7   r   g       @é   )r=   r   r>   r   r?   r@   )r   rA   rB   rC   Ún0r!   Úd1Úd2Út2Ún0_1rD   Útmp_basÚ_1_tÚi_n0_ts                 r   Ú
derivativezBezier.derivativeµ   sÍ  € ð ˆsŠ7�a˜#’gÜÐ>Ó?Ð?à�!‰G�tÒØˆAØ�o‰oˆÜ�‹HˆØ�‰UˆÜˆÜˆÜˆØ�‰UˆØ�A‰vˆØ�Š8Ø�s˜1‘v  A¡‘Ñ'ˆBØ�d‘˜c !™f s¨S°©V¡|Ñ3°c¸!±fÑ<Ñ=ˆBÜ�q–ˆAÜ% b¨!¨QÓ/ˆGØ�W˜s 1™vÑ%Ñ%ˆEØ�QŒ}˜�}Ø˜Q‘w�Ø˜R !™V™�Ø�f  D¡Ñ)¨GÑ3°c¸!±fÑ<Ñ<�ØØ˜f‘_ r¨B¡wÑ.°°c¸CÀ!¹G±mÑ1DÑDØ˜D‘y 4Ñ'ñ)àñð ˜!‘fññ�ð �C‹xØ˜3˜r™7 S¨¡YÑ.Ñ/�Ø˜$‘Y # b¡'¨A°°D±	©MÑ"9¸CÀÀQÁ¹KÑ"GÑH‘ð ð  �b˜"ˆ}Ðr   c              #  ó@   K  — |D ]  }| j                  |«      –— Œ y­w)z§Returns multiple (point, 1st derivative, 2nd derivative) tuples for
        parameter vector  `t` as :class:`Vec3` objects.
        Parameters in range [0, 1]
        N)rS   rF   s      r   ÚderivativeszBezier.derivativesÛ   s!   è ø€ ó ˆAØ—/‘/ !Ó$Ó$ñ ùrH   c                óP   — t        t        t        | j                  «      «      «      S )u>   Returns a new BÃ¨zier-curve with reversed control point order.)r   ÚlistÚreversedr   r   s    r   ÚreversezBezier.reverseå   s   € ä”dœ8 D×$7Ñ$7Ó8Ó9Ó:Ð:r   c                ó`   — t        |j                  | j                  «      «      }t        |«      S )z¨General transformation interface, returns a new :class:`Bezier` curve.

        Args:
             m: 4x4 transformation matrix (:class:`ezdxf.math.Matrix44`)

        )r   Útransform_verticesr   r   )r   Úmr   s      r   Ú	transformzBezier.transformé   s*   € ô ˜!×.Ñ.¨t×/BÑ/BÓCÓDˆ	Ü�iÓ Ð r   N)r   zIterable[UVec])ÚreturnzSequence[Vec3])é   )r   Úintr^   úIterable[Vec3])é   )r#   r/   r   r`   r^   ra   )r   r`   r^   úIterable[float])rA   r/   r^   r   )rA   rc   r^   ra   )rA   r/   r^   ztuple[Vec3, Vec3, Vec3])rA   rc   r^   z!Iterable[tuple[Vec3, Vec3, Vec3]])r^   r   )r\   r	   r^   r   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   Úpropertyr   r   r5   r   r!   r   rS   rU   rY   r]   © r   r   r   r   L   s`   „ ñó*@ð òó ðô2ô($óT7óó  ó$ðL%Ø ð%à	*ó%ó;ô!r   c                óÎ   — |dk(  r|dk(  rd}nt        ||«      }| |k(  r|dk(  rd}nt        d|z
  | |z
  «      }t        | «      t        |«      t        | |z
  «      z  z  }||z  |z  S )Nr-   r   r,   )ÚpowÚ	factorial)rC   rD   rA   ÚtiÚtniÚNis         r   r@   r@   ô   ss   € àˆC‚x�A˜’FØ‰ä��A‹YˆØˆA‚v�!�s’(Ø‰ä�3˜‘7˜a !™eÓ%ˆÜ	�1‹œ 1›¬	°!°a±%Ó(8Ñ8Ñ	9€BØ�‰7�S‰=Ðr   )Úmaxsizec                ó,   — t        j                  | «      S r   )r0   rl   )rC   s    r   rl   rl     s   € ä�>‰>˜!ÓÐr   )rC   r`   rD   r`   rA   r/   r^   r/   )rC   r`   )Ú
__future__r   Útypingr   r   Ú	functoolsr   r0   Únumpyr8   Ú
ezdxf.mathr   r   r	   r
   Ú__all__r   r@   rl   ri   r   r   Ú<module>rx      sV   ðõ #ß %Ý Û Û ç 4Ó 4ð ˆ*€ð:÷ze!ñ e!óPñ �4Ôòó ñr   