OgW ^dZddlmZddlmZmZmZmZmZm Z m Z ddl Z ddl Z ddlmZmZmZmZmZmZmZmZmZddlmZddlmZdd lmZer dd lmZmZmZm Z gd Z! d8 d9d Z"d:dZ# d; ddZ%d?dZ&d@dAdZ'dAdZ(dBdZ)dCdDdZ*dCdDdZ+ dE dFdZ,dGdZ-dGdZ.dGdZ/dGdZ0dGdZ1dHdZ2 dI dJdZ3 dI dKdZ4 dLd Z5 dMd!Z6 dNd"Z7Gd#d Z8dOd$Z9 dP dQd%Z: dP dQd&Z; dR dSd'Z dT dUd)Z?dTdVd*Z@dWd+ZA dXd,ZBe dYd-ZCdZd.ZD d[d/ZEd0d1d2d3 d\d4ZFGd5d6ZGd]d7ZHy)^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_pointsr$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_pointsrBpointscontrol_pointsr;tm1m2 start_tangent end_tangents W/var/www/html/public_html/myphp/venv/lib/python3.12/site-packages/ezdxf/math/bspline.pyrrZs2YYz "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 r6r7r)cubic_bezier_interpolationbezier_to_bspline)r rCrDrE ezdxf.mathrRrS)rGrHrRrS bezier_curvess rOr!r!sAYYz "F 6{Q788H.v6M ] ++rPctj|}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` rr6z$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.r9) r rCrDrErr&r(r%r$) rGrArBr> _fit_pointscountr:t_vectorknot_generation_method _tangentsrIr;bsplines rOrrs0T))J'K  E!E   u})?xHIIOK89H*01*Y)IIh' y>Q $M! ! & % !NE^s;/ /?Y  H  !K +A! nE?G NrPcddlm}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_tangentsr8r9) parametrizer`r rCr)r$)rGr>rBr`rYr]rIr;s rOrrsW:/))J'KIIh' %k6: KYNE >% 88rPct|}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 rr6zInvalid count/order combination)intr)rZr:knps rOr0r0s_ E A E QA AA  q1u =>> =>> q519rPc(|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 r6max)r:rBs rOr3r37s   ua=rPct|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 r6rh)r:s rOr4r4Is ua=rPcR|d}|d|z }|Dcgc] }||z |z  c}Scc}w)z(Normalize knot vector into range [0, 1].rr?)r;min_valmax_valvs rOnormalize_knotsrpUs6AhGBi'!G-2 3Q[G # 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)rZr:rF max_value knot_values rOr1r1\sA%%-!+,  5:55=5I JzJ " 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`` rrrc3.K|] }d|zz yw)rrNrl).0rorus rO z+open_uniform_knot_vector..s91#'Y&9)rsextendrt)rZr:rFrdtailr;rus @rOr2r2osv  A%%-!+, uu} ay5  EEME LL9a99 LL LrPcvt|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.rrxr?rrz.Parametrization vector t has to be normalized.rXrWz Unknown knot generation method: ) rcrrsmathiscloserEr,r+r.r-)rerfrJr> constrainedr:ros rOr*r*s" AJE APQQaqAts{$,,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] rrxr?rrrc3FK|]}t||zz ywNsumrzjrfrJs rOr{z/averaged_knots_unconstrained..s%D1Qq1q5\"Q&Ds!z!Normalized [0, 1] values required)rrr}rtrErerfrJr;s `` rOr+r+s Q43;; <<"s ## # EQUOE LLDaQ0CDD Ry3<== LL#!a%! LrPcddk(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] rrxr?rrrc3LK|]}t||zdz z yw)rNrrs rOr{z-averaged_knots_constrained..s*AqQq1q519%&*As!$)rrr}rtrs `` rOr,r,sq Q43;; <<"s ## # EQUOE LLAE!a%LAA LL#!a%! LrPc|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] rrxr?rrrr6rrr}rs rOr-r-q Q43;; <<"s ## # EQUOE LL1q1uqy!" LL#!a%! LrPc|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] rrxr?rrrrrs rOr.r.rrPc|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 rrxr?rrrr6@@N)rrappendr})rerfrJuprev_tu1t1s rOr/r/s! Q43;; <<"s ## # QA F B"g  6 IIv{c) * IIbM} "q&! 1v:?c12 6AF?c12 HHR !a%!)_HHaeckS !HHcUa!e_ HrPcLt|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)rrArKrLAs rO_get_best_solverr&s ffmm ,v& ||b!!&--00 ,,VuEB  ( (R 8$$QB//rPctt|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:rZdtype) r*rDrr basis_vectornparrayfloat64 solve_matrixr rCrows) rGrAr[r\r;NrJsolvermat_BrIs rOr%r%=s2 ' J!  E E!3z?CA (CQq~~a0CV 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 rr@rWr6Trrrxrrr?) rDr*rrinsertrrr rCr)rGrMrNrAr[r\rerfr;rrrspacingrrIs rOr&r&ds:> J!AA z"+ & Aq(2 E EQa!e4A'/ 0!ANN1  0D 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].rr6rl)up1up2fr;rfs rO coefficients1z2cad_fit_point_interpolation..coefficients1s`AElAEl QK#  G B#) c * G  rPctdz }|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].rr6rrrrD)mump1ump2rr;rfs rO coefficients2z2cad_fit_point_interpolation..coefficients2s JNQUQYQUQY QK3: & t  B#*t# $d 3sTz B t   rPr<rr@r6rWT)r>rrrxr?r)return list[float]) rCrrDr*rrrr rrr) rGrrr[rerrrrrrIr;rfs @@rOr'r's%"    OJ89H J!A A & Aq(9$ E EQa!e4A'/ 0!ANN1  0D 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)Nrrerx) find_spanbasis_funcs_derivatives)rJspanfrontbackbasisrrZrfs rOnbasisz>global_bspline_interpolation_first_derivatives..nbasissl{{1~qqy1}t#..tQ!.< 7E%%-%'3%$,6 6 7sAArr6rrrrxrrc3.K|] }|ywrrl)rzrJrs rOr{zAglobal_bspline_interpolation_first_derivatives..s 0AfQi 0r|r?Nc32K|]}t|ywrr)rzrows rOr{zAglobal_bspline_interpolation_first_derivatives.. s)3s8)szinhomogeneous matrix detectedr)rJrs) rDr/rr}rsetziprrr rCr)rG derivativesrAr[rer;rncolsrrBrrrIrrZrrfs @@@@rOr(r(s27 A J!A Ax (E  Oa E EQe4A ## t u ** A !IE 0!B 0- +##fu++,-HHcUeai 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 r6r@rrrxg0@g(@gBrr?Nrrr8) rDrtmagnitude_squaredotrquadratic_equationrEr} magnituderr0)rGrBrAr:rIrparamsip0p3t0t3abc alpha_plus alpha_minusp1p2r;max_uroknots rOr)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 TrFz knot values required, got .rrx)weightsr) r tuplerrDrcrr2rErprrrr)selfrIr:r;rrZrequired_knot_counts rO__init__zBSpline.__init__qs $zz.9D(()E  5=ug3E7:PQVPWX  =,UETJE%LE"'%- 5z00 *++Fs5zlRSTQx3'.E5%A Cfu ./14VSvw=P9QUV9V rPc d|jd|jdt|jdt|j d S)NzBSpline degree=z, z control points, z knot values, z weights)rArZrDr;rrs rO__str__zBSpline.__str__sLdkk]"TZZL9"4::<014<<>"#8 - rPc|jS)z4Control points as tuple of :class:`~ezdxf.math.Vec3`)rrs rOrIzBSpline.control_pointss###rPc,t|jS)z7Count of control points, (n + 1 in text book notation).)rDrrs rOrZz BSpline.counts4''((rPc.|jjS)zBiggest `knot`_ value.)rmax_trs rOrz BSpline.max_t{{   rPc.|jjS)zOrder (k) of B-spline = p + 1)rr:rs rOr:z BSpline.orderrrPc.|jjS)z"Degree (p) of B-spline = order - 1)rrArs rOrAzBSpline.degrees{{!!!rPcBt|j|jSr)rrrrs rO evaluatorzBSpline.evaluatorsd&:&:;;rPc.|jjS)z?Returns ``True`` if curve is a rational B-spline. (has weights))r is_rationalrs rOrzBSpline.is_rationals{{&&&rPc|jS)z7Returns ``True`` if curve is a clamped (open) B-spline.)rrs rO is_clampedzBSpline.is_clampeds}}rPct|||S)z/Returns :class:`BSpline` defined by fit points.r=)r)rHrAr>s rOfrom_fit_pointszBSpline.from_fit_pointss,FF6JJrPcXt|j|j|dS)zaReturns an ellipse approximation as :class:`BSpline` with `num` control points. r6rA)rverticesr)ellipsenums rOellipse_approximationzBSpline.ellipse_approximations* ,   W^^C0 1!  rPcXt|j|j|dS)z]Returns an arc approximation as :class:`BSpline` with `num` control points. r6r )rr angles)arcrs rOarc_approximationzBSpline.arc_approximations# ,CLLC,IRSTTrPct|dS)zoReturns the ellipse as :class:`BSpline` of 2nd degree with as few control points as possible. rsegments)r )rs rO from_ellipsezBSpline.from_ellipses -WqAArPcrt|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 rOfrom_arczBSpline.from_arcs, ) JJ COOS]]Q  rPcpt|j|j|j|jS)zInterface to the `NURBS-Python `_ package. Returns a :class:`BSpline` object from a :class:`geomdl.BSpline.Curve` object. rIr:r;r)r$ctrlptsr: knotvectorr)curves rOfrom_nurbs_python_curvezBSpline.from_nurbs_python_curves/ ==++""MM   rPc fd}jtjj|jrtj SdS)zZReturns a new :class:`BSpline` object with reversed control point order. c3jKttjD] }d|z  yw)Nrr)reversedrpr;)rdrs rO reverse_knotsz&BSpline.reverse..reverse_knotss/odjjl;< Ag  s03Nr ) __class__r'rIr:rr)rr(s` rOreversezBSpline.reversesf  ~~#D$7$78**/040@0@HT\\^,   GK   rPc.|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 rOr;z BSpline.knotss {{   rPc.|jjS)zlReturns a tuple of weights values as floats, one for each control point or an empty tuple. )rrrs rOrzBSpline.weights s {{"""rPcV|jj|j|S)ziApproximates curve by vertices as :class:`Vec3` objects, vertices count = segments + 1. )rrHrrrs rO approximatezBSpline.approximates" ~~$$T[[%:;;rPc|j}||jdz }||j}tj|||dzS)z7Yield evenly spaced parameters for given segment count.r)r;r:rZrlinspace)rrr; lower_bound upper_bounds rOrzBSpline.paramssF DJJN+ DJJ' {{; X\BBrPc# 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 rOr?z"BSpline.flattening..subdiv0su_+E&A .q!Q7x!!Q777!!Qu555 %   85sEA1 AA1A-A1A/A1 A*'A1)A**A1/A1rrN)r8r r9r r:rsr;rs)rruniquerr;rr6r) rr>rr;seg_f64rJ start_pointrdeltanext_t end_pointrr?s ` @@rO 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 DrPrxInvalid position tr)rQrcrr )rr_insert_knot_rationalrCr;rrArrrrtrr$r:)rrJrSrdrrRr;rfs ` @@@rO insert_knotzBSpline.insert_knots ;; " "--a0 0T[[&&'t++, KK E E 8qDJJ 45 5 KK ! !! $ q5 45 58=a!eaiQ8O!P1)A,!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||zzSrPrl)rQr hg_pointsr;rfrJs rOrSz0BSpline._insert_knot_rational..new_pointsOE%L(U519-=e -LMAUQY'1q51Ie4Dq4HH HrPrxrTrr;r)rQrcrnp.typing.NDArray)rr TypeErrorrCr;to_homogeneous_pointsrArrrtolistrtfrom_homogeneous_pointsrr$r:) rrJrSrd new_pointsrrHrrYr;rfs ` @@@rOrUzBSpline._insert_knot_rationals{{&&<= =!$++"3"34'Qa%BJJuQU|U1X>q519Dax$Qx%(2q$+MA+0E!a%L584K+LF1t8a<(MHq!a% DAq5DqA"1a!eR0* &q1u +8+;e+CmEG 5[G*,* a(* 1u3@3C*40 D))M* *1u8Fa$hQRUVQV7W"1t8a!e4Q 2 =!esEH2B!H2&AH20H2c|*t|j|j|}nt|j|}ddlm}||S)uApproximate arbitrary B-splines (degree != 3 and/or rational) by multiple segments of cubic Bézier curves. The choice of cubic Bézier curves is based on the widely support of this curves by many render backends. For cubic non-rational B-splines, which is maybe the most common used B-spline, is :meth:`bezier_decomposition` the better choice. 1. approximation by `level`: 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, a level >= 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)rR)rCrHapproximation_paramsr/bezier_interpolationrR)rlevelrrHrRs rOcubic_bezier_approximationz"BSpline.cubic_bezier_approximation sK<  $++d&?&?&FGHF$**845FD)&11rPctt|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<rrrr)rCrrrDrrtsubdivide_params)rrwrrrf_s rOruzBSpline.approximation_params1sod&:&:GDE v;! M :: JJE)/0Aa%i0F0uqy! 4A*623F 4 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_elevationrHs rOr}zBSpline.degree_elevationEs a((rP: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 )rr6rrrs rOrzBSpline.point_inversionQs!$ $u+w~TX  rPct||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 rOmeasurezBSpline.measuregs4**rPct||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_bsplinerHs rOsplitz BSpline.splittsT1%%rP)r8NN)rIIterable[UVec]r:rcr;Optional[Iterable[float]]rr)rzSequence[Vec3])rrcrrs)rr)r@r<)rHrrr$))rrrrcrr$)rrrrcrr$)rrrr$)rrrr$)rr$)rSequence[float])r)rrcrIterable[Vec3])rrcrIterable[float])r8)r>rsrrcrzIterator[Vec3])rJrsrr )rJrrr)r6)rJrsrercr list[Vec3])rJrrercrIterable[list[Vec3]])rJrsrr$)rrrr$)rrrr$)rr)r@N)rwrcrz Optional[int]rzIterable[Bezier4P])r@)rwrcrr)rJrcrr$)r6r rrs)r)rrcrr)rJrsrtuple[BSpline, BSpline]),__name__ __module__ __qualname____doc__ __slots__rrpropertyrIrZrr:rArrr staticmethodr rrrrr$r*r;rr/rrFr6rHrKrrVrUrcrfrsrxrur}rrrrlrPrOr$r$Us2:I +/-1 W&WW) W + W: $$))!!!!""<<''KK  UUBB       "!#<C)(V'( /0 3<I6 J<3~9=$2$2(5$2 $2L( )'+3Q   , + &rPc#Ktt|dz D]}||||||dzzdz |dyw)Nrrr?)rtrD)rfrs rOrzrzsQ 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 rr1rDr$)rIr:rrr;s rOr"r"s6"jj0O O 4eu ME >eW MMrPctj|}|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 rCr}r")rIr:rrs rOr#r#s` ii/O?;UQY78w-w{+,  @@rPctttj|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|] }|zzywrrl)rzrfrrs rOr{z,rational_bspline_from_arc..sF!!f*-Fr|r@rIrr;r:)r rsrradiansrnurbs_arc_parametersr$) rrrrr start_radend_radrIrr;s `` rOrrsx$&\F 6]F [3./I$,,'9+y'QRRG%9)Wh%W"NGU F~F  rPrcjtjz}|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_axisrfrIrs rOtransform_control_pointsz?rational_bspline_from_ellipse..transform_control_pointssZgnn%#### 7A6ACC<'&133,6 6 7sAAr@r)rr) start_paramrtau param_spanrr$)rrrrrrr;rIs` @rOr r sf%%0Kg000I7&:Y&"NGU /1  rPc |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).r6rrr)rxrxrxr8r@) rErirceilPI_2cosr sinrtrrDr}r0)rrr delta_angle arc_count segment_anglesegment_angle_2 arc_weightrIrangledr{r;stepgs rOrrs!|<==k)KDIIkD018*Q.2Q6#=C DD A c' aV T  c' LL#.s>/BAFUSTU 7E ))rPclitdfd 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)Nrrrx)KeyError) rrfretval dominatorf1f2rcacher;rs rOrzbspline_basis..NBs !Q=  Av#Ah!:eAEl:!!a%L583 AJa%(li/!Aq1u+=PS!!a%!),uQU|; !1q519%)Y61q5!a%H b"E1a&MM! s BB('B()rrcrfrcrrs)rsrc)rrQrAr;rrs` `@@rO bspline_basisr0s4+-E aA* SZV %%rPc 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?rr)rDrtrrr)rrZrAr;rQrs rObspline_basis_vectorrZso" u:%&.1, -- -AE!Ha)C3q!a%=#'2 > 8gadmd1g&==a >  > !81HEDr'C4!8 $+CAtn X\!ebj4x!BqEzb2a5j9 #be sSyBq1uI.E E1Cxr6TBY%55#%1r6 ?c"9C(+eBi39bSTf :U(UE"I(+eBi39bSTf :U(UE"IFAFA!GB!ebj  ) , 6T A"$BtdQh  AIDsC!G$ AQxBtH AID  q5 |D!H!QQU3DQUOA FAB(*BtdRi!m $w a%z b1BaJ FEG*bqb!G ax[j[!^$%('%:;TQ1q5;;.." ugR8L*u:L5M rtrKrrrr)rbr6rrrr prev_distancerrJ chk_pointsrrfr>no_progress_counter iterationdpdudiffs rOrrOs_& LLE%LM  A AudT2AfmmA&'JQ #%A>>!$ m #b A$M % !>* ##A#+45y>> g  " H! << x 0 1 $ "Q& H#$   TXXd^dhhtn ,, s7A YA56 HrPcTeZdZdZd 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: rxTr)rr$r\typercrE_splinerr1r _parametersrCrHrextminextmax_measure _distancescumsum_offsets)rrbrrHbboxs rOrzMeasurement.__init__s&'*=d6l^LM Mx= a<6xjAB B ;;sFLL(Q,QUVdll))$*:*:;<6"kk kk --/ $//2 rPc|d}tjt|tj}t |D]\}}|j |||<|}|S)Nrr)rrjrDr enumerater>)rHprev distancesrQr6s rOr zMeasurement._measures[ayHHS[ ; %f- LE5#}}U3Ie D rPc2t|jdS)z0Returns the approximated length of the B-spline.r?)rsr rs rOlengthzMeasurement.lengthsT]]2&''rPc,|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. rxrightsider) rrrrr searchsortedr rsr )rrJrrQrt2r>s rOr>zMeasurement.distances 8  "" ";; !!8 E] EAI ??519-R8BGDT]]5)H455rPc<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. rrrrxr) rrr rrDrrrsr )rr>rQrrrrrs rOparam_atzMeasurement.param_ats xgF A:!! CK <<%% %qy 4==#66 D\ E]R27}tu7M'MNNOOrPc|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: )rErrrrrrr)rrZ total_length seg_lengthr>rresultrJs rOdividezMeasurement.divides 19ug67 7"kk !E)  "" % h'A<<q) a  "H %  rPN)rbr$rrcrNone)rHrrr[r)rJrsrrs)r>rsrrs)rZrcrr) rrrrrrr rrr>rr!rlrPrOrrsD 3(( 6P rPrctd}||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_trrrNrZ)rErr:rfullrcrr;rr concatenaterIrDrr$)rbrJtolr:rr;rknots1knots2rH split_indexpoints1points2weights1weights2rs rOrrsJ C3w3446<<# 788 LLE qA  # #A &F HHV\\^2:: 6E ??5!' 2D5D\F 45\F^^QK (F " "Ff+%K\k"G[\"G "H "HnnG 7|strrr$)z5-pointsN)rGrr>r/rBr.rr$)rZrcr:rcrrc)T)r:rcrrc)r;rrr)F)rZrcr:rcrr)rXF)rercrfrcrJrrr)rercrfrcrJrrr)rzlist | linalg.MatrixrArcrz linalg.Solver)rX) rGzSequence[UVec]rArcr[rr\r/rtuple[list[Vec3], list[float]])rGrrMr rNr rArcr[rr\r/rr0)rGrrr0) rGrrrrArcr[rrr0)rGrrBrrr0)rfrrr)r8N)rIrr:rcrrrr$)rrrrr) rr rrsrrsrrsrrcrr$)r)rrrrcrr$)rrsrrsrrc) rrsrQrcrArcr;rrrs) rrsrZrcrArcr;rrr)rbr$rJrcrr$)rbr$rr[)rYzIterable[Sequence[float]]rr0)rbr$r6r rrs)rbr$rJrsrr)Ir __future__rtypingrrrrrr r rnumpyrrTr r r rrrrrrrrrezdxf.lldxf.constrrrrr__all__rr!rrr0r3r4rpr1r2r*r+r,r-r.r/rr%r&r'r(r)r$rzr"r#rpirr rrrr}r]r_rrrrlrPrOr7s #    + H*.**&* *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!ri&i&X)-N"N N'N N0)-A"A A'A A2        @ ww}34 ,/ B3*l'&T "%.=6@@F ( # .2#A< <  <  < ~ZZz-rP