Ë
    £èh6  ã                  óŽ   — d dl mZ d dlmZmZmZmZmZ d dlZddl	m
Z
mZ ddlmZ dgZdd„Z ed	ee
«      Z G d
„ dee   «      Zy)é    )Úannotations)ÚIteratorÚSequenceÚOptionalÚGenericÚTypeVarNé   )ÚVec3ÚVec2)ÚMatrix44ÚBezier3Pc                óH   — d| cxk  rdk  st        d«      ‚ t        d«      ‚y )Nç        ç      ð?zt not in range [0 to 1])Ú
ValueError)Úts    ú4lib/python3.12/site-packages/ezdxf/math/_bezier3p.pyÚcheck_if_in_valid_ranger      s/   € Ø�!Œ?�sŠ?ÜÐ2Ó3Ð3ð ÜÐ2Ó3Ð3ð ó    ÚTc                  óz   — e Zd ZdZdZdd„Zedd„«       Zdd„Zdd„Z	dd„Z
ddd„Zddd	„Zdd
„Zdd„Zdd„Zdd„Zy)r   uN  Implements an optimized quadratic `BÃ©zier curve`_ for exact 3 control
    points.

    The class supports points of type :class:`Vec2` and :class:`Vec3` as input, the
    class instances are immutable.

    Args:
        defpoints: sequence of definition points as :class:`Vec2` or
            :class:`Vec3` compatible objects.

    ©Ú_control_pointsÚ_offsetc                óì   ‡— t        |«      dk7  rt        d«      ‚|d   j                  }|j                  dvrt	        d|j                  › �«      ‚|d   Š‰| _        t        ˆfd„|D «       «      | _        y )Né   zThree control points required.r   )r   r
   zinvalid point type: c              3  ó(   •K  — | ]	  }|‰z
  –— Œ y ­w)N© )Ú.0ÚpÚoffsets     €r   Ú	<genexpr>z$Bezier3P.__init__.<locals>.<genexpr>8   s   øè ø€ Ð3RÉ	À1°A¸µJÉ	ùs   ƒ)Úlenr   Ú	__class__Ú__name__Ú	TypeErrorr   Útupler   )ÚselfÚ	defpointsÚ
point_typer!   s      @r   Ú__init__zBezier3P.__init__-   sx   ø€ Üˆy‹>˜QÒÜÐ=Ó>Ð>Ø˜q‘\×+Ñ+ˆ
Ø×"Ñ"Ð&6Ñ6ÜÐ2°:×3FÑ3FÐ2GÐHÓIÐIð ˜a‘LˆØ ˆŒä.3Ó3RÉ	Ó3RÓ.RˆÕr   c                óP   — | j                   \  }}}| j                  }|||z   ||z   fS )zBControl points as tuple of :class:`Vec3` or :class:`Vec2` objects.r   )r(   Ú_Úp1Úp2r!   s        r   Úcontrol_pointszBezier3P.control_points:   s3   € ð ×(Ñ(‰	ˆˆ2ˆrØ—‘ˆØ�r˜F‘{ B¨¡KÐ/Ð/r   c                ó:   — t        |«       | j                  |«      S )u¡   Returns direction vector of tangent for location `t` at the
        BÃ¨zier-curve.

        Args:
            t: curve position in the range ``[0, 1]``

        )r   Ú_get_curve_tangent©r(   r   s     r   ÚtangentzBezier3P.tangentB   s   € ô 	  Ô"Ø×&Ñ& qÓ)Ð)r   c                ó:   — t        |«       | j                  |«      S )uƒ   Returns point for location `t` at the BÃ¨zier-curve.

        Args:
            t: curve position in the range ``[0, 1]``

        )r   Ú_get_curve_pointr3   s     r   ÚpointzBezier3P.pointM   s   € ô 	  Ô"Ø×$Ñ$ QÓ'Ð'r   c              #  ó¸   K  — |dk  rt        |«      ‚d|z  }| j                  }|d   –— t        d|«      D ]  }| j                  ||z  «      –— Œ |d   –— y­w)u¾   Approximate `BÃ©zier curve`_ by vertices, yields `segments` + 1
        vertices as ``(x, y[, z])`` tuples.

        Args:
            segments: count of segments for approximation

        r	   r   r   é   N)r   r0   Úranger6   )r(   ÚsegmentsÚdelta_tÚcpÚsegments        r   ÚapproximatezBezier3P.approximateW   sg   è ø€ ð �aŠ<Ü˜XÓ&Ð&Ø˜x™ˆØ× Ñ ˆØ�‰eŠÜ˜Q Ö)ˆGØ×'Ñ'¨°'Ñ(9Ó:Ó:ð *à�‰e‹ùs   ‚AAc                ój   — d}d}| j                  |«      D ]  }|�||j                  |«      z  }|}Œ |S )u_   Returns estimated length of BÃ¨zier-curve as approximation by line
        `segments`.
        r   N)r?   Údistance)r(   r;   ÚlengthÚ
prev_pointr7   s        r   Úapproximated_lengthzBezier3P.approximated_lengthh   sJ   € ð ˆØ"&ˆ
Ø×%Ñ% hÖ/ˆEØÐ%Ø˜*×-Ñ-¨eÓ4Ñ4�Ø‰Jð 0ð ˆr   c              #  ó¸  K  — g }d|z  }d}| j                   }|d   }|–— |dk  r³||z   }t        j                  |d«      r|d   }	d}n| j                  |«      }		 ||z   dz  }
| j                  |
«      }|j	                  |	«      }|j                  |«      }||k  r|	–— |}|	}|r|j                  «       \  }}	nn|j                  ||	f«       |
}|}	Œw|dk  rŒ²yy­w)aB  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 quadratic (C2)
                curve to the center of the linear (C1) curve between two
                approximation points to determine if a segment should be
                subdivided.
            segments: minimum segment count

        r   r   r   r9   g      à?N)r0   ÚmathÚiscloser6   ÚlerprA   ÚpopÚappend)r(   rA   r;   ÚstackÚdtÚt0r=   Ústart_pointÚt1Ú	end_pointÚmid_tÚ	mid_pointÚ	chk_pointÚds                 r   Ú
flatteningzBezier3P.flatteningt   s  è ø€ ð (*ˆØ˜(‘NˆØˆà× Ñ ˆØ˜A™ˆð ÒØ�3ŠhØ�b‘ˆBÜ�|‰|˜B Ô$Ø˜q™E�	Ø‘à ×1Ñ1°"Ó5�	àØ " R¡¨3™�Ø#×4Ñ4°UÓ;�	Ø*×/Ñ/°	Ó:�	à×&Ñ& yÓ1�Ø�x’<Ø#’OØ�BØ"+�KÙØ(-¯	©	«™˜™Iàà—L‘L " i Ô1Ø�BØ )�Ið# ð �3�hùs   ‚CCÃCc                óv   — | j                   \  }}}d|z
  }d|z  |z  }||z  }||z  ||z  z   | j                  z   S )Nr   ç       @r   )r(   r   r-   r.   r/   Ú
_1_minus_tÚbÚcs           r   r6   zBezier3P._get_curve_point¦   sP   € ð ×(Ñ(‰	ˆˆ2ˆrØ˜1‘Wˆ
à�!‰G�jÑ ˆØ�‰Eˆà�A‰v˜˜Q™‰ §¡Ñ-Ð-r   c                óR   — | j                   \  }}}dd|z  z
  }d|z  }||z  ||z  z   S )NrW   g      @)r   )r(   r   r-   r.   r/   rY   rZ   s          r   r2   zBezier3P._get_curve_tangent±   s=   € ð ×(Ñ(‰	ˆˆ2ˆrà�#˜‘'‰MˆØ�!‰GˆØ�A‰v˜˜Q™‰Ðr   c                óP   — t        t        t        | j                  «      «      «      S )u>   Returns a new BÃ¨zier-curve with reversed control point order.)r   ÚlistÚreversedr0   )r(   s    r   ÚreversezBezier3P.reverse»   s   € äœœX d×&9Ñ&9Ó:Ó;Ó<Ð<r   c                ó†   — t        j                  | j                  «      }t        t	        |j                  |«      «      «      S )zºGeneral transformation interface, returns a new :class:`Bezier3P`
        curve and it is always a 3D curve.

        Args:
             m: 4x4 transformation :class:`Matrix44`

        )r
   Úgenerater0   r   r'   Útransform_vertices)r(   Úmr)   s      r   Ú	transformzBezier3P.transform¿   s3   € ô —M‘M $×"5Ñ"5Ó6ˆ	Üœ˜a×2Ñ2°9Ó=Ó>Ó?Ð?r   N)r)   úSequence[T])Úreturnre   )r   Úfloatrf   r   )r;   Úintrf   úIterator[T])é€   )r;   rh   rf   rg   )é   )rA   rg   r;   rh   rf   ri   )rf   zBezier3P[T])rc   r   rf   zBezier3P[Vec3])r%   Ú
__module__Ú__qualname__Ú__doc__Ú	__slots__r+   Úpropertyr0   r4   r7   r?   rD   rU   r6   r2   r_   rd   r   r   r   r   r      sW   „ ñ
ð /€IóSð ò0ó ð0ó	*ó(óô"
ô0*ód	.óó=ô	@r   )r   rg   rf   ÚNone)Ú
__future__r   Útypingr   r   r   r   r   rF   Ú_vectorr
   r   Ú	_matrix44r   Ú__all__r   r   r   r   r   r   Ú<module>rw      sS   ðõ #÷õ ó ÷  Ý ð ˆ,€ó4ñ
 ˆC��tÓ€ôj@ˆw�q‰zõ j@r   