hfdZddlmZddlmZmZmZmZmZm Z m Z ddl Z ddl Z ddlmZmZmZmZmZmZmZmZmZddlmZddlmZdd lmZer dd lmZmZmZm Z gd Z! d9 d:d Z"d;dZ# d< d=dZ$ d> d?dZ%d@dZ&dAdBdZ'dBdZ(dCdZ)dDdEdZ*dDdEdZ+ dF dGdZ,dHdZ-dHdZ.dHdZ/dHdZ0dHdZ1dIdZ2 dJ dKdZ3 dJ dLdZ4 dMd Z5 dNd!Z6 dOd"Z7Gd#d Z8dPd$Z9 dQ dRd%Z: dQ dRd&Z; dS dTd'Z dU dVd)Z?dUdWd*Z@dXd+ZA dYd,ZBe dZd-ZCd[d.ZD d\d/ZEd0d1d2d3 d]d4ZFGd5d6ZGd^d7ZHd_d8ZIy)`aG B-Splines ========= https://www.cl.cam.ac.uk/teaching/2000/AGraphHCI/SMEG/node4.html Rational B-splines ================== https://www.cl.cam.ac.uk/teaching/2000/AGraphHCI/SMEG/node5.html: "The NURBS Book" by Les Piegl and Wayne Tiller https://books.google.at/books/about/The_NURBS_Book.html?id=7dqY5dyAwWkC&redir_esc=y ) annotations)IterableIteratorSequence TYPE_CHECKINGOptionalAny no_type_checkN) Vec3UVecNULLVECBasis Evaluatorcreate_t_vectorestimate_end_tangent_magnitudedistance_point_line_3darc_angle_span_deg) BoundingBox)linalg) DXFValueError)ConstructionArcConstructionEllipseMatrix44Bezier4P)fit_points_to_cad_cvglobal_bspline_interpolation!local_cubic_bspline_interpolationrational_bspline_from_arcrational_bspline_from_ellipsefit_points_to_cubic_bezieropen_uniform_bsplineclosed_uniform_bsplineBSpline*unconstrained_global_bspline_interpolation)global_bspline_interpolation_end_tangentscad_fit_point_interpolation.global_bspline_interpolation_first_derivatives/local_cubic_bspline_interpolation_from_tangentsknots_from_parametrizationaveraged_knots_unconstrainedaveraged_knots_constrainednatural_knots_unconstrainednatural_knots_constrained double_knotsrequired_knot_valuesuniform_knot_vectoropen_uniform_knot_vectorrequired_fit_pointsrequired_control_points round_knotsr$cVtj|}t|dkr td|t |\}}t |d|Stj|}t |d\}}|dj|}|dj|} t|d || fd S) aReturns a cubic :class:`BSpline` from fit points as close as possible to common CAD applications like BricsCAD. There exist infinite numerical correct solution for this setup, but some facts are known: - CAD applications use the global curve interpolation with start- and end derivatives if the end tangents are defined otherwise the equation system will be completed by setting the second derivatives of the start and end point to 0, for more information read this answer on stackoverflow: https://stackoverflow.com/a/74863330/6162864 - The degree of the B-spline is always 3 regardless which degree is stored in the SPLINE entity, this is only valid for B-splines defined by fit points - Knot parametrization method is "chord" - Knot distribution is "natural" Args: fit_points: points the spline is passing through tangents: start- and end tangent, default is autodetect two or more points required orderknotschordmethodr)degreetangentsr?) r listlen ValueErrorr'r$r normalizer) fit_pointsrCpointscontrol_pointsr<tm1m2 start_tangent end_tangents 2lib/python3.12/site-packages/ezdxf/math/bspline.pyrr[s2YYz "F 6{Q788 ;F C~Qe<< (A +F7 CFBaDNN2&MB%//"%K '-  ctj|}t|dkr tdddlm}m}||}||S)uReturns a cubic :class:`BSpline` from fit points **without** end tangents. This function uses the cubic Bèzier interpolation to create multiple Bèzier curves and combine them into a single B-spline, this works for short simple splines better than the :func:`fit_points_to_cad_cv`, but is worse for longer and more complex splines. Args: fit_points: points the spline is passing through r7r8r)cubic_bezier_interpolationbezier_to_bspline)r rDrErF ezdxf.mathrSrT)rHrIrSrT bezier_curvess rPr!r!sAYYz "F 6{Q788H.v6M ] ++rQctj|}t|}|dz}|r|dz }||kDr|td|tt ||}|dzrdnd}|qtj|} t| dk(rt || d| d|||\} } nEt| t|k(rt || ||\} } ntdt||||\} } t| || } | S) a`B-spline`_ interpolation by the `Global Curve Interpolation`_. Given are the fit points and the degree of the B-spline. The function provides 3 methods for generating the parameter vector t: - "uniform": creates a uniform t vector, from 0 to 1 evenly spaced, see `uniform`_ method - "chord", "distance": creates a t vector with values proportional to the fit point distances, see `chord length`_ method - "centripetal", "sqrt_chord": creates a t vector with values proportional to the fit point sqrt(distances), see `centripetal`_ method - "arc": creates a t vector with values proportional to the arc length between fit points. It is possible to constraint the curve by tangents, by start- and end tangent if only two tangents are given or by one tangent for each fit point. If tangents are given, they represent 1st derivatives and should be scaled if they are unit vectors, if only start- and end tangents given the function :func:`~ezdxf.math.estimate_end_tangent_magnitude` helps with an educated guess, if all tangents are given, scaling by chord length is a reasonable choice (Piegl & Tiller). Args: fit_points: fit points of B-spline, as list of :class:`Vec3` compatible objects tangents: if only two vectors are given, take the first and the last vector as start- and end tangent constraints or if for all fit points a tangent is given use all tangents as interpolation constraints (optional) degree: degree of B-spline method: calculation method for parameter vector t Returns: :class:`BSpline` rr7z$More fit points required for degree naturalaveragerzoInvalid count of tangents, two tangents as start- and end tangent constrains or one tangent for each fit point.r:) r rDrErFrr&r(r%r$) rHrBrCr? _fit_pointscountr;t_vectorknot_generation_method _tangentsrJr<bsplines rPrrs0T))J'K  E!E   u})?xHIIOK89H*01*Y)IIh' y>Q $M! ! & % !NE^s;/ /?Y  H  !K +A! nE?G NrQcddlm}tj|}|rtj|}n |||}t ||\}}t |d|S)a`B-spline`_ interpolation by 'Local Cubic Curve Interpolation', which creates B-spline from fit points and estimated tangent direction at start-, end- and passing points. Source: Piegl & Tiller: "The NURBS Book" - chapter 9.3.4 Available tangent estimation methods: - "3-points": 3 point interpolation - "5-points": 5 point interpolation - "bezier": cubic bezier curve interpolation - "diff": finite difference or pass pre-calculated tangents, which overrides tangent estimation. Args: fit_points: all B-spline fit points as :class:`Vec3` compatible objects method: tangent estimation method tangents: tangents as :class:`Vec3` compatible objects (optional) Returns: :class:`BSpline` r)estimate_tangentsr9r:) parametrizerar rDr)r$)rHr?rCrarZr^rJr<s rPrrsW:/))J'KIIh' %k6: KYNE >% 88rQct|}t|dz }|dz }d|cxkr|dzkstdtd||zdzS)uvReturns the count of required knot-values for a B-spline of `order` and `count` control points. Args: count: count of control points, in text-books referred as "n + 1" order: order of B-Spline, in text-books referred as "k" Relationship: "p" is the degree of the B-spline, text-book notation. - k = p + 1 - 2 ≤ k ≤ n + 1 rr7zInvalid count/order combination)intr)r[r;knps rPr0r0s_ E A E QA AA  q1u =>> =>> q519rQc(|r|dz}t|dS)zReturns the count of required fit points to calculate the spline control points. Args: order: spline order (degree + 1) tangents: start- and end tangent are given or estimated r7max)r;rCs rPr3r38s   ua=rQct|dS)zReturns the required count of control points for a valid B-spline. Args: order: spline order (degree + 1) Required condition: 2 <= order <= count, therefore: count >= order r7ri)r;s rPr4r4Js ua=rQcR|d}|d|z }|Dcgc] }||z |z  c}Scc}w)z(Normalize knot vector into range [0, 1].rr@)r<min_valmax_valvs rPnormalize_knotsrqVs:AhGBi'!G-2 3UQ[G #U 33 3s$cv|rt||zdz }nd}t||zDcgc]}||z  c}Scc}w)aReturns an uniform knot vector for a B-spline of `order` and `count` control points. `order` = degree + 1 Args: count: count of control points order: spline order normalize: normalize values in range [0, 1] if ``True`` r?)floatrange)r[r;rG max_value knot_values rPr1r1]sG%%-!+,  5:55=5I J5IzJ "5I JJ Js 6c||z }|rt||z dzdg|z}n dd|zg|z}dg|z}|jfdt|D|j||S)aReturns an open (clamped) uniform knot vector for a B-spline of `order` and `count` control points. `order` = degree + 1 Args: count: count of control points order: spline order normalize: normalize values in range [0, 1] if ``True`` rrsc3.K|] }d|zz yw)rsNrm).0rprvs rP z+open_uniform_knot_vector..s91#'Y&)rtextendru)r[r;rGretailr<rvs @rPr2r2psv  A%%-!+, uu} ay5  EEME LL9a99 LL LrQcvt|dz}||dzkDr td|Dcgc] }t|}}|ddk7stj|dds t d|dk(r|r t |||St|||S|d k(r|r t|||St|||St d |cc}w) aReturns a 'clamped' knot vector for B-splines. All knot values are normalized in the range [0, 1]. Args: n: count fit points - 1 p: degree of spline t: parametrization vector, length(t_vector) == n, normalized [0, 1] method: "average", "natural" constrained: ``True`` for B-spline constrained by end derivatives Returns: List of n+p+2 knot values as floats rz2Invalid n/p combination, more fit points required.rryr@rsz.Parametrization vector t has to be normalized.rYrXz Unknown knot generation method: ) rdrrtmathiscloserFr,r+r.r-)rfrgrKr? constrainedr;rps rPr*r*s" AJE APQQ1aq1Ats{$,,quc2IJJ  'q!Q / .aA6 9  &aA . -Q15 ;F8DEE# sB6cddk(sJtjddsJdgdzz}|jfdtd|z dzD|ddkDr t d|jdgdzz|S)zReturns an averaged knot vector from parametrization vector `t` for an unconstrained B-spline. Args: n: count of control points - 1 p: degree t: parametrization vector, normalized [0, 1] rryr@rsrc3FK|]}t||zz ywNsumr{jrgrKs rPr|z/averaged_knots_unconstrained..s(D0C1Qq1q5\"Q&0Cs!z!Normalized [0, 1] values required)rrr~rurFrfrgrKr<s `` rPr+r+s Q43;; <<"s ## # EQUOE LLDaQ0CDD Ry3<== LL#!a%! LrQcddk(sJtjddsJdgdzz}|jfdt|z D|jdgdzz|S)zReturns an averaged knot vector from parametrization vector `t` for a constrained B-spline. Args: n: count of control points - 1 p: degree t: parametrization vector, normalized [0, 1] rryr@rsrc3LK|]}t||zdz z yw)rNrrs rPr|z-averaged_knots_constrained..s+ALqQq1q519%&*Ls!$)rrr~rurs `` rPr,r,sq Q43;; <<"s ## # EQUOE LLAE!a%LAA LL#!a%! LrQc|ddk(sJtj|ddsJdg|dzz}|j|d||z dz|jdg|dzz|S)zReturns a 'natural' knot vector from parametrization vector `t` for an unconstrained B-spline. Args: n: count of control points - 1 p: degree t: parametrization vector, normalized [0, 1] rryr@rsrr7rrr~rs rPr-r-q Q43;; <<"s ## # EQUOE LL1q1uqy!" LL#!a%! LrQc|ddk(sJtj|ddsJdg|dzz}|j|d||z dz|jdg|dzz|S)zReturns a 'natural' knot vector from parametrization vector `t` for a constrained B-spline. Args: n: count of control points - 1 p: degree t: parametrization vector, normalized [0, 1] rryr@rsrrrs rPr.r.rrQc|ddk(sJtj|ddsJdg|dzz}d}g}|ddD]}|dk(r)|j||zdz |j|nN|dk(r|j|dz n4|jd|z|zdz |j|d|zzdz |}|j|d |dz|z |j|d dzdz |jdg|dzz|S) a0Returns a knot vector from parametrization vector `t` for B-spline constrained by first derivatives at all fit points. Args: n: count of fit points - 1 p: degree of spline t: parametrization vector, first value has to be 0.0 and last value has to be 1.0 rryr@rsrr7@@N)rrappendr~)rfrgrKuprev_tu1t1s rPr/r/s Q43;; <<"s ## # QA F B"g 6 IIv{c) * IIbM} "q&! 1v:?c12 6AF?c12HHR !a%!)_HHaeckS !HHcUa!e_ HrQcLt|tjstj|}|jdkrtj|j Stj |d\}}tj|||}tj|||S)zmReturns best suited linear equation solver depending on matrix configuration and python interpreter. F) check_all) isinstancerMatrixnrows NumpySolvermatrixdetect_banded_matrixcompact_banded_matrixBandedMatrixLU)rrBrLrMAs rP_get_best_solverr's ffmm ,v& ||b!!&--00 ,,VuEB  ( (R 8$$QB//rQctt|dz |||d}t||dzt|}t|Dcgc]}|j |c}|}t j |t j}|j|} tj| j|fScc}w)arInterpolates the control points for a B-spline by global interpolation from fit points without any constraints. Source: Piegl & Tiller: "The NURBS Book" - chapter 9.2.1 Args: fit_points: points the B-spline has to pass degree: degree of spline >= 2 t_vector: parametrization vector, first value has to be 0 and last value has to be 1 knot_generation_method: knot generation method from parametrization vector, "average" or "natural" Returns: 2-tuple of control points as list of Vec3 objects and the knot vector as list of floats rFrr<r;r[dtype) r*rErr basis_vectornparrayfloat64 solve_matrixr rDrows) rHrBr\r]r<NrKsolvermat_BrJs rPr%r%>s2 ' J!  E E!3z?CA (C(Qq~~a0(CV LF HHZrzz 2E((/N 99^((* +U 22DsB;c6t|dz }|}|dkDrd}t|dz|||d}t||dz|dz} |D cgc]} | j| } } dg|dzz} | j dd d g| z| j d | d d gz|j d|||dz|z z|j d |d ||dz z |z zt | |} | j |}tj|j|fScc} w) aCalculates the control points for a B-spline by global interpolation from fit points and the 1st derivative of the start- and end point as constraints. These 'tangents' are 1st derivatives and not unit vectors, if an estimation of the magnitudes is required use the :func:`estimate_end_tangent_magnitude` function. Source: Piegl & Tiller: "The NURBS Book" - chapter 9.2.2 Args: fit_points: points the B-spline has to pass start_tangent: 1st derivative as start constraint end_tangent: 1st derivative as end constrain degree: degree of spline >= 2 t_vector: parametrization vector, first value has to be 0 and last value has to be 1 knot_generation_method: knot generation method from parametrization vector, "average" or "natural" Returns: 2-tuple of control points as list of Vec3 objects and the knot vector as list of floats rrArXr7Trrryrsr@) rEr*rrinsertrrr rDr)rHrNrOrBr\r]rfrgr<rrrspacingrrJs rPr&r&es;> J!AA z"+ & Aq(2 E EQa!e4A'/ 0x!ANN1 xD 0eq1uoGKKD$<')*KKGtTl*+a%A,*:;<b+#Ah*?1)DEF dF +F((4N 99^((* +U 22 1sDcl d fd }d fd }tt|d}t|dz }d t|dz |dd  t dz|dz }|Dcgc]}|j |}}d g|z}|j d||z|j d ||z|j dtd d d |j d td d d t| } | j|} tj| j fScc}w)aCalculates the control points for a B-spline by global interpolation from fit points without any constraints in the same way as AutoCAD and BricsCAD. Source: https://stackoverflow.com/a/74863330/6162864 Args: fit_points: points the B-spline has to pass Returns: 2-tuple of control points as list of Vec3 objects and the knot vector as list of floats cjdz}dz}dz z|z }||z | ||zz||zz ||z gS)z*Returns the coefficients for equation [1].rr7rm)up1up2fr<rgs rP coefficients1z2cad_fit_point_interpolation..coefficients1s`AElAEl QK#  G B#) c * G  rQctdz }|z dz }|z dz }dz zd|z z }|d|z z | d|z |z zd|z z d|z z |d|z z gS)z,Returns the coefficients for equation [n-1].rr7rsrrE)mump1ump2rr<rgs rP coefficients2z2cad_fit_point_interpolation..coefficients2s JNQUQYQUQY QK3: & t  B#*t# $d 3sTz B t   rQr=rrAr7rXT)r?rrryr@r)return list[float]) rDrrEr*rrrr rrr) rHrrr\rfrrrrrrJr<rgs @@rPr'r's&"    OJ89H J!A A & Aq(9$ E EQa!e4A'/ 0x!ANN1 xD 0eaiGKK=?W,-KKGmo-.aaA'b$q!Q-( dA &F((4N 99^((* +U 22 1s!D1c bdfd |t|dz }t||}t|dzt|dzdgdgdz zzddgdgdz zzg}t|d}fd |dd DD]$}|j|D cgc]} | d | c} &|j dgdz zddgz|j dgdz zdgztt d |Ddk(sJd g} t ||D]} | j| | d| d c| d <| d<| dxx|dzz zcc<| dxxd|dz z z zcc<t||} | j| } tj| j|fScc} w)aInterpolates the control points for a B-spline by a global interpolation from fit points and 1st derivatives as constraints. Source: Piegl & Tiller: "The NURBS Book" - chapter 9.2.4 Args: fit_points: points the B-spline has to pass derivatives: 1st derivatives as constrains, not unit vectors! Scaling by chord length is a reasonable choice (Piegl & Tiller). degree: degree of spline >= 2 t_vector: parametrization vector, first value has to be 0 and last value has to be 1 Returns: 2-tuple of control points as list of Vec3 objects and the knot vector as list of floats c3Kj|}|z }zdz|z }j||dD]}dg|z|zdg|zzyw)Nrrfry) find_spanbasis_funcs_derivatives)rKspanfrontbackbasisrr[rgs rPnbasisz>global_bspline_interpolation_first_derivatives..nbasissg{{1~qqy1}t#..tQ!..s 0AfQir}r@Nc32K|]}t|ywrr)r{rows rPr|zAglobal_bspline_interpolation_first_derivatives.. s)q3s8qszinhomogeneous matrix detectedr)rKrt) rEr/rr~rsetziprrr rDr)rH derivativesrBr\rfr<rncolsrrBrrrJrr[rrgs @@@@rPr(r(s27 A J!A Ax (E  Oa E EQe4A ## t u ** A !IE 0!B 0 +##fu++,1HHcUeai D$< /0HHcUeai D6 )* s)q)) *a /P1PP /AJ , -R5!B%LAbE1R5aDE!a%L1 DbEcEAE(O#q ((E a (F((+N 99^((* +U 22',s F, cLt|t|k(sJt|dkDsJd}|dz}|dg}d}g}tt|dz D]}||}||dz} ||} ||dz} d| | zjz } d| |z j| | zz} d| |z jz} t j | | |\}}||| zd z z}| || zd z z }|j||f|d ||z jzz }|j||j|d dg|z}|d }|d d D]}||z }|j||f|jd gd zt|tt||k(sJ||fS#t $rYPwxYw)aGInterpolates the control points for a cubic B-spline by local interpolation from fit points and tangents as unit vectors for each fit point. Use the :func:`estimate_tangents` function to estimate end tangents. Source: Piegl & Tiller: "The NURBS Book" - chapter 9.3.4 Args: fit_points: curve definition points - curve has to pass all given fit points tangents: one tangent vector for each fit point as unit vectors Returns: 2-tuple of control points as list of Vec3 objects and the knot vector as list of floats r7rArrryg0@g(@gBrr@Nrsr9) rErumagnitude_squaredotrquadratic_equationrFr~ magnituderr0)rHrCrBr;rJrparamsip0p3t0t3abc alpha_plus alpha_minusp1p2r<max_urpknots rPr)r)s& z?c(m ++ + z?Q   F QJE m_N A F 3z?Q& ' ] A  a[ a!e_ BG-- - BG==b) ) R"W.. . &,&?&?1a&H #J *r/C' ' *r/C' 'r2h' SBG&& && a!("*R.) EEME 2JE CR[5y dD\" LL# u:-c..A5I II I 5  #   s.F F#"F#ceZdZdZdZ d- d.dZdZed/dZed0dZ ed1dZ ed0d Z ed0d Z ed2d Z ed Zed Zed3d4dZed5d6dZed5d7dZed8dZed9dZed:dZd:dZd;dZd;dZddZd?d@dZdAdZdBdZdCdDdZdCdEdZ dFdZ!dFdZ"dGd Z#dHd!Z$dId"Z% dJ dKd#Z&dLdMd$Z'dNd%Z(d&d'd(d) dOd*Z)dPdQd+Z*dRd,Z+y)Sr$aB-spline construction tool. Internal representation of a `B-spline`_ curve. The default configuration of the knot vector is a uniform open `knot`_ vector ("clamped"). Factory functions: - :func:`fit_points_to_cad_cv` - :func:`fit_points_to_cubic_bezier` - :func:`open_uniform_bspline` - :func:`closed_uniform_bspline` - :func:`rational_bspline_from_arc` - :func:`rational_bspline_from_ellipse` - :func:`global_bspline_interpolation` - :func:`local_cubic_bspline_interpolation` Args: control_points: iterable of control points as :class:`Vec3` compatible objects order: spline order (degree + 1) knots: iterable of knot values weights: iterable of weight values )_control_points_basis_clampedNctj||_t|j}t |}||kDrt d|d|d||t ||d}nKt|}||z}t||k7rt|dt|d|dd k7r t|}t|||| |_ tt|d|d k(xrtt|| dd k(|_ y) Nzgot z control points, need z or more for order of TrGz knot values required, got .rry)weightsr) r tuplerrErdrr2rFrqrrrr)selfrJr;r<rr[required_knot_counts rP__init__zBSpline.__init__rs $zz.9D(()E  5=ug3E7:PQVPWX  =,UETJE%LE"'%- 5z00 *++Fs5zlRSTQx3'.E5%A Cfu ./14VSvw=P9QUV9V rQc d|jd|jdt|jdt|j d S)NzBSpline degree=z, z control points, z knot values, z weights)rBr[rEr<rrs rP__str__zBSpline.__str__sLdkk]"TZZL9"4::<014<<>"#8 - rQc|jS)z4Control points as tuple of :class:`~ezdxf.math.Vec3`)rrs rPrJzBSpline.control_pointss###rQc,t|jS)z7Count of control points, (n + 1 in text book notation).)rErrs rPr[z BSpline.counts4''((rQc.|jjS)zBiggest `knot`_ value.)rmax_trs rPrz BSpline.max_t{{   rQc.|jjS)zOrder (k) of B-spline = p + 1)rr;rs rPr;z BSpline.orderrrQc.|jjS)z"Degree (p) of B-spline = order - 1)rrBrs rPrBzBSpline.degrees{{!!!rQcBt|j|jSr)rrrrs rP evaluatorzBSpline.evaluatorsd&:&:;;rQc.|jjS)z?Returns ``True`` if curve is a rational B-spline. (has weights))r is_rationalrs rPrzBSpline.is_rationals{{&&&rQc|jS)z7Returns ``True`` if curve is a clamped (open) B-spline.)rrs rP is_clampedzBSpline.is_clampeds}}rQct|||S)z/Returns :class:`BSpline` defined by fit points.r>)r)rIrBr?s rPfrom_fit_pointszBSpline.from_fit_pointss,FF6JJrQcXt|j|j|dS)zaReturns an ellipse approximation as :class:`BSpline` with `num` control points. r7rB)rverticesr)ellipsenums rPellipse_approximationzBSpline.ellipse_approximations* ,   W^^C0 1!  rQcXt|j|j|dS)z]Returns an arc approximation as :class:`BSpline` with `num` control points. r7r )rrangles)arcrs rParc_approximationzBSpline.arc_approximations# ,CLLC,IRSTTrQct|dS)zoReturns the ellipse as :class:`BSpline` of 2nd degree with as few control points as possible. rsegments)r )rs rP from_ellipsezBSpline.from_ellipses -WqAArQcrt|j|j|j|jdS)zkReturns the arc as :class:`BSpline` of 2nd degree with as few control points as possible. rr)rcenterradius start_angle end_angle)rs rPfrom_arczBSpline.from_arcs, ) JJ COOS]]Q  rQcpt|j|j|j|jS)zInterface to the `NURBS-Python `_ package. Returns a :class:`BSpline` object from a :class:`geomdl.BSpline.Curve` object. rJr;r<r)r$ctrlptsr; knotvectorr)curves rPfrom_nurbs_python_curvezBSpline.from_nurbs_python_curves/ ==++""MM   rQc fd}jtjj|jrtj SdS)zZReturns a new :class:`BSpline` object with reversed control point order. c3jKttjD] }d|z  yw)Nrs)reversedrqr<)rers rP reverse_knotsz&BSpline.reverse..reverse_knotss*odjjl;<Ag =s03Nr!) __class__r(rJr;rr)rr)s` rPreversezBSpline.reversesf  ~~#D$7$78**/040@0@HT\\^,   GK   rQc.|jjS)zReturns a tuple of `knot`_ values as floats, the knot vector **always** has order + count values (n + p + 2 in text book notation). )rr<rs rPr<z BSpline.knotss {{   rQc.|jjS)zlReturns a tuple of weights values as floats, one for each control point or an empty tuple. )rrrs rPrzBSpline.weightss {{"""rQcV|jj|j|S)ziApproximates curve by vertices as :class:`Vec3` objects, vertices count = segments + 1. )rrIrrrs rP approximatezBSpline.approximates" ~~$$T[[%:;;rQc|j}||jdz }||j}tj|||dzS)z7Yield evenly spaced parameters for given segment count.r)r<r;r[rlinspace)rrr< lower_bound upper_bounds rPrzBSpline.paramssF DJJN+ DJJ' {{; X\BBrQc# Kd fd |j tjtj|j }tj |}|d} j |}||ddD][}||z |z }||ks||z} tj| |r|} j | }  || || Ed{| }| }||krK]y7w)aAdaptive recursive flattening. The argument `segments` is the minimum count of approximation segments between two knots, 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 projected curve point onto the segment chord. segments: minimum segment count between two knots c3K||zdz}j|} t|||}|kr|y ||||Ed{ ||||Ed{y#t$rd}Y>wxYw7)7w)Ng?r)pointrZeroDivisionError) sestart_tend_tmid_tr_distdistancersubdivs rPr@z"BSpline.flattening..subdiv1su_+E&A .q!Q7x!!Q777!!Qu555 %   85sEA1 AA1A-A1A/A1 A*'A1)A**A1/A1rrN)r9r r:r r;rtr<rt)rruniquerr<rr7r) rr?rr<seg_f64rK start_pointrdeltanext_t end_pointrr@s ` @@rP flatteningzBSpline.flattening$s 6NN  "((4::<01**X& !Hooa( )B!Vw&Eb&U::fb)F%OOF3 !+y!VDDD' b&EsBC%.new_pointsNU5\!eEAI&6u&EFA519%Q/'%.12DD DrQryInvalid position tr)rRrdrr )rr_insert_knot_rationalrDr<rrBrrrrurr$r;)rrKrTrerrSr<rgs ` @@@rP insert_knotzBSpline.insert_knots  ;; " "--a0 0T[[&&'t++, KK E E 8qDJJ 45 5 KK ! !! $ q5 45 58=a!eaiQ8O!P8O1)A,8O!PA A QUAw E22"QsDcd |jjs tdt|jj t ||j d fd }dks|jk\r td|jj}| kr tdj}t| z dz|dzDcgc] }|| c}|| z dz|t|\}} j|dzt||j |Scc}w)z&Knot insertion for rational B-splines.zRequires a rational B-splines.c`|z |z|z z }|dz d|z z||zzSrQrm)rRr hg_pointsr<rgrKs rPrTz0BSpline._insert_knot_rational..new_pointsOE%L(U519-=e -LMAUQY'1q51Ie4Dq4HH HrQryrUrr<r)rRrdrnp.typing.NDArray)rr TypeErrorrDr<to_homogeneous_pointsrBrrrtolistrufrom_homogeneous_pointsrr$r;) rrKrTre new_pointsrrIrrZr<rgs ` @@@rPrVzBSpline._insert_knot_rationals{{&&<= =!$++"3"34'= 3 is recommended. 2. approximation by a given count of evenly distributed approximation segments. Args: level: subdivision level of approximation segments (ignored if argument `segments` is not ``None``) segments: absolute count of approximation segments Returns: Yields control points of cubic Bézier curves as :class:`Bezier4P` objects r)rS)rDrIapproximation_paramsr0bezier_interpolationrS)rlevelrrIrSs rPcubic_bezier_approximationz"BSpline.cubic_bezier_approximation sK<  $++d&?&?&FGHF$**845FD)&11rQctt|jd}t|dk(r|S|jdk7r|j}|Dcgc]}||z }}t |dz D]}tt |}|Scc}w)a}Returns an educated guess, the first level of approximation segments is based on the count of control points and their distribution along the B-spline, every additional level is a subdivision of the previous level. E.g. a B-Spline of 8 control points has 7 segments at the first level, 14 at the 2nd level and 28 at the 3rd level. r=rrsr)rDrrrErrusubdivide_params)rrurrrg_s rPrszBSpline.approximation_params0sod&:&:GDE v;! M :: JJE)/0Aa%iF0uqy!A*623F" 1s Bct||S)a/Returns a new :class:`BSpline` with a t-times elevated degree. Degree elevation increases the degree of a curve without changing the shape of the curve. This method implements the algorithm A5.9 of the "The NURBS Book" by Piegl & Tiller. .. versionadded:: 1.4 )degree_elevationrIs rPr{zBSpline.degree_elevationDs a((rQ:0yE>depsilonmax_iterationsinitc4t|t||||S)aOReturns the parameter t for a point on the curve that is closest to the input point. This is an iterative search using Newton's method, so there is no guarantee of success, especially for splines with many turns. Args: point(UVec): point on the curve or near the curve epsilon(float): desired precision (distance input point to point on curve) max_iterations(int): max iterations for Newton's method init(int): number of points to calculate in the initialization phase .. versionadded:: 1.4 r)point_inversionr )rr7rrrs rPrzBSpline.point_inversionPs!$ $u+w~TX  rQct||S)zReturns a B-spline measurement tool. All measurements are based on the approximated curve. Args: segments: count of segments for B-spline approximation. .. versionadded:: 1.4 ) Measurementr/s rPmeasurezBSpline.measurefs4**rQct||S)zSplits the B-spline at parameter `t` and returns two new B-splines. Raises: ValuerError: t out of range 0 < t < max_t .. versionadded:: 1.4 ) split_bsplinerIs rPsplitz BSpline.splitssT1%%rQ)r9NN)rJIterable[UVec]r;rdr<Optional[Iterable[float]]rr)rzSequence[Vec3])rrdrrt)rr)rAr=)rIrrr$))rrrrdrr$)rrrrdrr$)rrrr$)rrrr$)rr$)rSequence[float])r)rrdrIterable[Vec3])rrdrIterable[float])r9)r?rtrrdrzIterator[Vec3])rKrtrr )rKrrr)r7)rKrtrfrdr list[Vec3])rKrrfrdrIterable[list[Vec3]])rKrtrr$)rrrr$)rrrr$)rr)rAN)rurdrz Optional[int]rzIterable[Bezier4P])rA)rurdrr)rKrdrr$)r7r rrt)r})rrdrr)rKrtrtuple[BSpline, BSpline]),__name__ __module__ __qualname____doc__ __slots__rrpropertyrJr[rr;rBrrr  staticmethodr rrrrr%r+r<rr0rrGr7rIrLrrWrVrdrgrqrvrsr{rrrrmrQrPr$r$Vs2:I +/-1 W&WW) W + W: $$))!!!!""<<''KK  UUBB       "!#<C)(V'( /0 3<I6 J:3z9=$2$2(5$2 $2L( )'+3Q   , + &rQc#Ktt|dz D]}||||||dzzdz |dyw)Nrrr@)rurE)rgrs rPrxrxsL 3q6A: d taAh#%% B%Ks?Acxtj|}tt||d}t ||||S)akCreates an open uniform (periodic) `B-spline`_ curve (`open curve`_). This is an unclamped curve, which means the curve passes none of the control points. Args: control_points: iterable of control points as :class:`Vec3` compatible objects order: spline order (degree + 1) weights: iterable of weight values Fr)r;r<r)r rr1rEr$)rJr;rrr<s rPr"r"s6"jj0O O 4eu ME >eW MMrQctj|}|j|d|dz |"t|}|j|d|dz t|||S)aJCreates a closed uniform (periodic) `B-spline`_ curve (`open curve`_). This B-spline does not pass any of the control points. Args: control_points: iterable of control points as :class:`Vec3` compatible objects order: spline order (degree + 1) weights: iterable of weight values Nr)r rDr~r")rJr;rrs rPr#r#s` ii/O?;UQY78w-w{+,  @@rQctttj|dz}|tjt ||z}t |||\}}} t fd|D|| dS)aReturns a rational B-splines for a circular 2D arc. Args: center: circle center as :class:`Vec3` compatible object radius: circle radius start_angle: start angle in degrees end_angle: end angle in degrees segments: count of spline segments, at least one segment for each quarter (90 deg), default is 1, for as few as needed. hc3.K|] }|zzywrrm)r{rgrrs rPr|z,rational_bspline_from_arc..sF~!!f*-~r}rArJrr<r;)r rtrradiansrnurbs_arc_parametersr$) rrrrr start_radend_radrJrr<s `` rPrrsx$&\F 6]F [3./I$,,'9+y'QRRG%9)Wh%W"NGU F~F  rQrcjtjz}|jz}dfd }t |||\}}t |||dS)u/Returns a rational B-splines for an elliptic arc. Args: ellipse: ellipse parameters as :class:`~ezdxf.math.ConstructionEllipse` object segments: count of spline segments, at least one segment for each quarter (π/2), default is 1, for as few as needed. c3Ktj}j}j}D]&}|||jzz||j zz(ywr)r r major_axis minor_axisxy)rx_axisy_axisrgrJrs rPtransform_control_pointsz?rational_bspline_from_ellipse..transform_control_pointssUgnn%####A6ACC<'&133,6 6 sAArAr)rr) start_paramrtau param_spanrr$)rrrrrrr<rJs` @rPr r sf%%0Kg000I7&:Y&"NGU /1  rQc |dkr td||z }ttj|tz |}||z }|dz }tj |}t tj |tj|g}dg} |} dtj |dz z } t|D]} | |z } |jt tj | | ztj| | z| j|| |z } |jt tj | tj| | jdgd} dtt|dzddz dz dzz }|}|dkr| j||f||z }|dkr| jdgtt|dt| z z|| | fS) uUReturns a rational B-spline parameters for a circular 2D arc with center at (0, 0) and a radius of 1. Args: start_angle: start angle in radians end_angle: end angle in radians segments: count of segments, at least one segment for each quarter (π/2) Returns: control_points, weights, knots rz!Invalid argument segments (>= 1).r7rsr)ryryryr9rA) rFrjrceilPI_2cosr sinrurrEr~r0)rrr delta_angle arc_count segment_anglesegment_angle_2 arc_weightrJrangledryr<stepgs rPrrs!|<==k)KDIIkD018*Q.2Q6#=C DD A c' aV T  c' LL#.s>/BAFUSTU 7E ))rQclitdfd t|t|S)aCB-spline basis_vector function. Simple recursive implementation for testing and comparison. Args: u: curve parameter in range [0, max(knots)] index: index of control point degree: degree of B-spline knots: knots vector Returns: float: basis_vector value N_i,p(u) cV ||fS#t$r|dk(r| cxkr |dzkrnndnd}nh||z|z }|r |z |z ||dz znd}||zdz|dzz }|r!||zdz z |z |dz|dz znd}||z}|||f<|cYSwxYw)Nrrry)KeyError) rrgretval dominatorf1f2rcacher<rs rPrzbspline_basis..NAs !Q=  Av#Ah!:eAEl:!!a%L583 AJa%(li/!Aq1u+=PS!!a%!),uQU|; !1q519%)Y61q5!a%H b"E1a&MM! s BB('B()rrdrgrdrrt)rtrd)rrRrBr<rrs` `@@rP bspline_basisr/s4+-E aA* SZV %%rQc t|||zdzk(sJt|Dcgc]}t||||}}tj||drd|d<|Scc}w)aCreate basis_vector vector at parameter u. Used with the bspline_basis() for testing and comparison. Args: u: curve parameter in range [0, max(knots)] count: control point count (n + 1) degree: degree of B-spline (order = degree + 1) knots: knot vector Returns: list[float]: basis_vector vector, len(basis_vector) == count rr@rs)rErurrr)rr[rBr<rRrs rPbspline_basis_vectorrYsq" u:%&.1, -- ->!$ m #b A$M $ !>* ##A#+45y>> g  " H! << x 0 1 $ "Q& H#$   TXXd^dhhtn ,, s7A YA5+6 HrQcTeZdZdZd dZed dZed dZd dZ d dZ ddZ y)rzvB-spline measurement tool. All measurements are based on the approximated curve. .. versionadded:: 1.4 ct|tstdt|t |}|dkrt d|||_tjd|j|dzd|_ t|j j|j}t|}|j|_|j|_|j!||_tj$|j"|_y)NzBSpline instance expected, got rzinvalid segment count: ryTr)rr$r]typerdrF_splinerr2r _parametersrDrIrextminextmax_measure _distancescumsum_offsets)rrcrrIbboxs rPrzMeasurement.__init__s&'*=d6l^LM Mx= a<6xjAB B ;;sFLL(Q,QUVdll))$*:*:;<6"kk kk --/ $//2 rQc|d}tjt|tj}t |D]\}}|j |||<|}|S)Nrr)rrrEr enumerater?)rIprev distancesrRr7s rPr zMeasurement._measuresVayHHS[ ; %f-LE5#}}U3Ie D.rQc2t|jdS)z0Returns the approximated length of the B-spline.r@)rtr rs rPlengthzMeasurement.lengthsT]]2&''rQc,|dkry||jjk\r |jS|j}t j ||d}||}||dz}|j |dz||z z||z z }t|j||zS)zfReturns the distance along the curve from the start point for then given parameter t. ryrightsider) rrrrr searchsortedr rtr )rrKrrRrt2r?s rPr?zMeasurement.distances 8  "" ";; !!8 E] EAI ??519-R8BGDT]]5)H455rQc<tj|j|d}|dkry|j}|t |k\r|j j S|dz }||j|z }||}||}t|||z ||j|z zzS)zcReturns the parameter t for a given distance along the curve from the start point. rrrryr) rrr rrErrrtr )rr?rRrrrrrs rPparam_atzMeasurement.param_ats xgF A:!! CK <<%% %qy 4==#66 D\ E]R27}tu7M'MNNOOrQc|dkrtd||j}||z }|}|jj}g}||krC|j |}t j ||s|j|||z }||krC|S)avReturns the interpolated B-spline parameters for dividing the curve into `count` segments of equal length. The method yields only the dividing parameters, the first (0.0) and last parameter (max_t) are not included e.g. dividing a B-spline by 3 yields two parameters [t1, t2] that divides the B-spline into 3 parts of equal length. rzinvalid count: )rFrrrrrrr)rr[ total_length seg_lengthr?rresultrKs rPdividezMeasurement.divides 19ug67 7"kk !E)  "" % h'A<<q) a  "H %  rQN)rcr$rrdrNone)rIrrr\r)rKrtrrt)r?rtrrt)r[rdrr) rrrrrrr rrr?rr!rmrQrPrrsD 3(( 6P rQrctd}||kr td||j|z kDr td|j}tj||}|j |}tj |jtj}tj||d}|d|}||d}tj||f}|j} t||z } | d| } | | d} g} g}|j}t|r |d| } || d}t| ||| t| |||fS) zSplits a B-spline at a parameter t. Raises: ValuerError: t out of range 0 < t < max_t .. versionadded:: 1.4 g-q=zt must be greater than 0zt must be smaller than max_trrrNr[)rFrr;rfullrdrr<rr concatenaterJrErr$)rcrKtolr;rr<rknots1knots2rI split_indexpoints1points2weights1weights2rs rPrrsJ C3w3446<<# 788 LLE qA  # #A &F HHV\\^2:: 6E ??5!' 2D5D\F 45\F^^QK (F " "Ff+%K\k"G[\"G "H "HnnG 7|r<s #    + J*.**&* *Z,2)- SS S'S  S  Sp)-'9'9 '9''9 '9T2$ 4K&6GL&F &F&F&&F&FR*&&&# L06#, $3$3 $3$3 $3 $ $3Z#, 33333333  33  33  33$33l>3>3#>3B>3>3>3 >3 >3 $ >3B6!6!&06!#6!rg&g&T)-N"N N'N N0)-A"A A'A A2        @ ww}34 ,/ B3*l'&T "%.=6@@F ( # .2#A< <  <  < ~ZZz-` 6rQ