hyl@ddlmZddlmZmZmZmZddlmZddl Z ddl Z ddl m Z mZmZmZmZmZmZgdZe j*dz Zd*d+d Z d, d-d Z d. d/d Zd0d Zd1dZd2dZd3dZ d4 d5dZ d6 d7dZdZ GddeZ!GddZ"d e d d8dZ#d d e d d9dZ$d e d d:dZ% d;dZ&GddZ'dd"Z*d?d#Z+efd@d$Z,d1d%Z-e d& dAd'Z.e d& dBd(Z/dCd)Z0y)D) annotations)SequenceIterableOptionalIterator)IntEnumN)Vec3Vec2Matrix44X_AXISY_AXISZ_AXISUVec)is_planar_facesubdivide_facesubdivide_ngonsPlanePlaneLocationStatenormal_vector_3psafe_normal_vectordistance_point_line_3dintersection_line_line_3dintersection_ray_polygon_3dintersection_line_polygon_3dbasic_transformationbest_fit_normalBarycentricCoordinateslinear_vertex_spacinghas_matrix_3d_stretchingspherical_envelopeinscribe_circle_tangent_length bending_anglesplit_polygon_by_plane is_face_normal_pointing_outwardsis_vertex_order_ccw_3d@& .>c8t|dkryt|dk(ryd}tt|dz D]N}|||dz\}}} ||z j||z j}||}:|j ||rNy|yy#t$rY`wxYw)zReturns ``True`` if sequence of vectors is a planar face. Args: face: sequence of :class:`~ezdxf.math.Vec3` objects abs_tol: tolerance for normals check FTNabs_tol)lenrangecross normalizeZeroDivisionErrorisclose)facer, first_normalindexabcnormals 6lib/python3.12/site-packages/ezdxf/math/construct3d.pyrr/s 4y1} 4yA~Ls4y1}%uuqy)1a !e]]1q5)335F  !L%%fg%>& !   s%B  BBTc#pKt|dkr tdt|}tj||z }t |Dcgc]}||j ||dz|z!}}t |D]0\}}|r||||||dz f||dz ||f||||f2ycc}ww)zSubdivides faces by subdividing edges and adding a center vertex. Args: face: a sequence of :class:`Vec3` quads: create quad faces if ``True`` else create triangles r)z3 or more vertices required.N)r- ValueErrorr sumr.lerp enumerate)r3quadslen_facemid_posisubdiv_locationr5vertexs r:rrKs 4y1}788IHhhtnx'G8=h#8G1Q T1q5H,-.##4 v /%0'?5ST9;UU U!%!),fg= =/%0'9 9 ) #sA B6 $B10AB6c#K|D]i}t||krtj|)tj|t|z }t |D]\}}||dz ||fkyw)zSubdivides faces into triangles by adding a center vertex. Args: faces: iterable of faces as sequence of :class:`Vec3` max_vertex_count: subdivide only ngons with more vertices r<N)r-r tupler>r@)facesmax_vertex_countr3rCr5rFs r:rrfsk t9( (**T" "hhtns4y0G!*4 v519ovw66"1 sA0A2cL||z j||z jS)zlReturns normal vector for 3 points, which is the normalized cross product for: :code:`a->b x a->c`. )r/r0)r6r7r8s r:rrzs$ E==Q  ) ) ++ct|dkr td|^}}}} ||z j||z jS#t$rt |cYSwxYw)zjSafe function to detect the normal vector for a face or polygon defined by 3 or more `vertices`. r)3 or more vertices required)r-r=r/r0r1r)verticesr6r7r8_s r:rrsh  8}q677KAq!a)A}}QU#--// )x(()s$AAActj|}t|dkr td|d}|j |ds|j ||j \}}}d}d}d}|ddD]B} | j \} } } ||| z|| z zz }||| z|| z zz }||| z|| z zz }| }| }| }Dt|||jS)zReturns the "best fit" normal for a plane defined by three or more vertices. This function tolerates imperfect plane vertices. Safe function to detect the extrusion vector of flat arbitrary polygons. r)rNrr<N)r listr-r=r2appendxyzr0) rO _verticesfirstprev_xprev_yprev_znxnynzvxyzs r:rrs (#I 9~677 aLE ==2 '"YYFFF B B B qr]%%1a vzfqj)) vzfqj)) vzfqj)) B  % % ''rLc|j|r td||z }||z j|}|j|jz }|dkryt j |S)zReturns the normal distance from a `point` to a 3D line. Args: point: point to test start: start point of the 3D line end: end point of the 3D line z Not a line.rS)r2r1projectmagnitude_squaremathsqrt)pointstartendv1v2diffs r:rrsh }}S .. B +  r "B  !4!4 4D s{yyrLcddlm}m}||||}t|dk7ry|d}|r|S||j |r||j |r|Sy)a Returns the intersection point of two 3D lines, returns ``None`` if lines do not intersect. Args: line1: first line as tuple of two points as :class:`Vec3` objects line2: second line as tuple of two points as :class:`Vec3` objects virtual: ``True`` returns any intersection point, ``False`` returns only real intersection points abs_tol: absolute tolerance for comparisons r)intersection_ray_ray_3d BoundingBoxr<N) ezdxf.mathrorpr-inside)line1line2virtualr,rorpresrhs r:rrsb$@ !% 8C 3x1} FE 5  'K,>,E,Ee,L rLc$t|\}}}tj|||}|r|tj|z}t|}|js8|tj |j |j|jz}|S)aReturns a combined transformation matrix for translation, scaling and rotation about the z-axis. Args: move: translation vector scale: x-, y- and z-axis scaling as float triplet, e.g. (2, 2, 1) z_rotation: rotation angle about the z-axis in radians ) r r scalez_rotateis_null translater`rarb)moverx z_rotationsxsyszmr{s r:rrsyeJBBr2r"A X  z **T I    X   Y[[)++ FF HrLceZdZdZdZdZdZy)rrr<r*r)N)__name__ __module__ __qualname__COPLANARFRONTBACKSPANNINGrLr:rrsH E DHrLrceZdZdZdZddZeddZeddZeddZ e ddZ e ddZ dd Z e Zd Zdd Zdd Zdd ZdddZdd dZded d!dZd"dZef d#dZy)$rzConstruction tool for 3D planes. Represents a plane in 3D space as a normal vector and the perpendicular distance from the origin. _normal_distance_from_origincJ|jdusJd||_||_y)NFzinvalid plane normal)rzrr)selfr9distances r:__init__zPlane.__init__s)~~&>(>>& %-"rLc|jS)zNormal vector of the plane.)rrs r:r9z Plane.normals||rLc|jS)z@The (perpendicular) distance of the plane from origin (0, 0, 0).)rrs r:distance_from_originzPlane.distance_from_origins)))rLc4|j|jzS)zReturns the location vector.rrs r:vectorz Plane.vectors||d8888rLc ||z j||z j}t ||j |S#t$r tdwxYw)z+Returns a new plane from 3 points in space.z"undefined plane: colinear vertices)r/r0r1r=rdot)clsr6r7r8ns r:from_3pz Plane.from_3p#s] CQ a!e$..0AQa!!! CAB B Cs %AAct|} t|j|jS#t$r t dwxYw)z3Returns a new plane from the given location vector.zinvalid NULL vector)r rr0 magnituder1r=)rrr_s r: from_vectorzPlane.from_vector,sD L 4 4 4  423 3 4s #1AcN|j|j|jS)zReturns a copy of the plane.) __class__rrrs r:__copy__zPlane.__copy__5s~~dllD,F,FGGrLcNdt|jd|jdS)NzPlane(z, ))reprrrrs r:__repr__zPlane.__repr__;s(T\\*+2d.H.H-IKKrLc`t|tstS|j|jk(SN) isinstancerNotImplementedr)rothers r:__eq__z Plane.__eq__>s%%'! !{{ell**rLcR|jj||jz S)a Returns signed distance of vertex `v` to plane, if distance is > 0, `v` is in 'front' of plane, in direction of the normal vector, if distance is < 0, `v` is at the 'back' of the plane, in the opposite direction of the normal vector. )rrrrr_s r:signed_distance_tozPlane.signed_distance_toCs$||"T%?%???rLcJtj|j|S)zPPzz#v&&rLc|j} |j|j|z |j|z }|||zzS#t$rYywxYw)zReturns the intersection point of the infinite 3D ray defined by `origin` and the `direction` vector and this plane or ``None`` if there is no intersection. A coplanar ray does not intersect the plane! N)r9rrr1)rorigin directionrrs r: intersect_rayzPlane.intersect_rayus^ KK //!%%-?155CSSFV+,,!  s0A AAc|jj||jz }|| krtjS||kDrtj Stj S)zjReturns the :class:`PlaneLocationState` of the given `vertex` in relative to this plane. )rrrrrrr)rrFr,rs r:rzPlane.vertex_location_statesY<<##F+d.H.HH wh %** *  %++ +%.. .rLN)r9r rfloat)returnr rr)r6r r7r r8r r'Plane')rrrr)rr)robjectrbool)r_r rrr')r_r rr)rrrr)rir rjr rOptional[Vec3])rr rr rr)rFr rr)rrr__doc__ __slots__rpropertyr9rr classmethodrrrcopyrrrrrr PLANE_EPSILONrrrrrLr:rrs 5I. **99""44H DL+ @5-  37 '' $' ', -%2 / /  /rLrrc"tj}g}g}g}t|}|j} |j} |D]*} |j | |} || z}|j | ,|tjk(r*|r|t|} | j| dkDr|}nY|}nU|tjk(r|}n>|tjk(r|}n'|tjk(rt|}t|D]}|dz|z}||} ||}||} ||}| tjk7r|j | | tjk7r|j | | |ztjk(s~| | j| z | j|| z z }| j||}|j ||j |t|dkrg}t|dkrg}t|t|fS)a7Split a convex `polygon` by the given `plane`. Returns a tuple of front- and back vertices (front, back). Returns also coplanar polygons if the argument `coplanar` is ``True``, the coplanar vertices goes into either front or back depending on their orientation with respect to this plane. rr<r))rrrTrr9rrUrrrrrr-r.r?rH)polygonplanerr, polygon_type vertex_typesfront_vertices back_verticesrOwr9rF vertex_typepolygon_normal len_verticesr5 next_indexnext_vertex_type next_vertexinterpolation_weightplane_intersection_points r:r#r#s&..L-/L!#N "MG}H ""A \\F11&'B  # K( )222 ,X6Nzz.)A-!) ( +11 1! +00 0 +44 48} <(E!)|3J&u-K+J7 e_F":.K0555%%f-0666$$V,..3E3N3NN()FJJv,>(>&**&(C($,2;;!5,(%%&>?$$%=>%)& ~  "N }  !M  % "6 66rL)rboundaryr,c t|}t|dkr td t|}t ||j |d}|j||||} | yt| ||||S#t$rYywxYw)aReturns the intersection point of the 3D line form `start` to `end` and the given `polygon`. Args: start: start point of 3D line as :class:`Vec3` end: end point of 3D line as :class:`Vec3` polygon: 3D polygon as iterable of :class:`Vec3` coplanar: if ``True`` a coplanar start- or end point as intersection point is valid boundary: if ``True`` an intersection point at the polygon boundary line is valid abs_tol: absolute tolerance for comparisons r)rNNrr) rTr-r=rr1rrr(_is_intersection_point_inside_3d_polygon) rirjrrrr,rOr9rips r:rrs.G}H 8}q677#H- &&**Xa[1 2E   eS8W  MB z 3 Hfh  s A66 BBrr,ct|}t|dkr td t|}t ||j |d}|j||}|yt|||||S#t$rYywxYw)aReturns the intersection point of the infinite 3D ray defined by `origin` and the `direction` vector and the given `polygon`. Args: origin: origin point of the 3D ray as :class:`Vec3` direction: direction vector of the 3D ray as :class:`Vec3` polygon: 3D polygon as iterable of :class:`Vec3` boundary: if ``True`` intersection points at the polygon boundary line are valid abs_tol: absolute tolerance for comparisons r)rNNr) rTr-r=rr1rrrr) rrrrr,rOr9rrs r:rrs*G}H 8}q677#H- &&**Xa[1 2E   VY /B z 3 Hfh  s A33 A?>A?cddlm}m}||}tj|j |}|t|j |||} | dkDs|r| dk(r|Sy)Nr)is_point_in_polygon_2dOCSr+)rqrrr rTpoints_from_wcsfrom_wcs) rrOr9rr,rrocs ocs_verticesstates r:rr$sa7 f+C99S00:;L " S\\"  g E qyX%1* rLc(eZdZdZddZddZddZy) rahBarycentric coordinate calculation. The arguments `a`, `b` and `c` are the cartesian coordinates of an arbitrary triangle in 3D space. The barycentric coordinates (b1, b2, b3) define the linear combination of `a`, `b` and `c` to represent the point `p`:: p = a * b1 + b * b2 + c * b3 This implementation returns the barycentric coordinates of the normal projection of `p` onto the plane defined by (a, b, c). These barycentric coordinates have some useful properties: - if all barycentric coordinates (b1, b2, b3) are in the range [0, 1], then the point `p` is inside the triangle (a, b, c) - if one of the coordinates is negative, the point `p` is outside the triangle - the sum of b1, b2 and b3 is always 1 - the center of "mass" has the barycentric coordinates (1/3, 1/3, 1/3) = (a + b + c)/3 ct||_t||_t||_|j|jz |_|j|jz |_|j|jz |_|jj|j }|j|_ |j|j|_ t|jdkr tdy)Nr'zinvalid triangle)r r6r7r8_e1_e2_e3r/r0_nr_denomabsr=)rr6r7r8e1xe2s r:rzBarycentricCoordinates.__init__Msaaa66DFF?66DFF?66DFF?txx(//#ii( t{{ d "/0 0 #rLct|}|j}|j}||jz }||jz }||j z }|j j|j||z }|jj|j||z }|jj|j||z } t||| Sr) r rrr6r7r8rr/rrr) rrrdenomd1d2d3b1b2b3s r:from_cartesianz%BarycentricCoordinates.from_cartesianZs G GG  Z Z Z XX^^B  # #A & . XX^^B  # #A & . XX^^B  # #A & .BBrLct|j\}}}|j|z|j|zz|j|zzSr)r rVr6r7r8)rr7rrrs r: to_cartesianz#BarycentricCoordinates.to_cartesianfs=!W[[ Bvv{TVVb[(466B;66rLN)r6rr7rr8r)rrrr )r7rrr )rrrrrrrrrLr:rr3s2 1  7rLrc|dkr||gS||z }|jr|g|zS|g}|j|j|dz z }td|dz D]}||z }|j ||j ||S)z=Returns `count` evenly spaced vertices from `start` to `end`.r*r<)rzr0rr.rU)rirjcountrrOsteprPs r:rrks zs|U{HwwH   h00EAI> ?D 1eai   ! OOC OrLc|jtj}|jt}|jt}t j ||j xs!t j ||j S)a4Returns ``True`` if matrix `m` performs a non-uniform xyz-scaling. Uniform scaling is not stretching in this context. Does not check if the target system is a cartesian coordinate system, use the :class:`~ezdxf.math.Matrix44` property :attr:`~ezdxf.math.Matrix44.is_cartesian` for that. )transform_directionr rer rrfr2)r ux_mag_sqruyuzs r:rr|sx&&v.??J  v &B  v &B||J(;(;< < DLLB''EArLcvtj|t|z tfd|D}|fS)zCalculate the spherical envelope for the given points. Returns the centroid (a.k.a. geometric center) and the radius of the enclosing sphere. .. note:: The result does not represent the minimal bounding sphere! c3@K|]}j|ywr)r).0rcentroids r: z%spherical_envelope..s6v!""1%vs)r r>r-max)pointsradiusrs @r:r r s7xx#f+-H 6v6 6F V rLc|j|}t|dz z }tjt |tryt tj ||zS)aReturns the tangent length of an inscribe-circle of the given `radius`. The direction `dir1` and `dir2` define two intersection tangents, The tangent length is the distance from the intersection point of the tangents to the touching point on the inscribe-circle. r&rS) angle_betweenPI2rfr2rtan)dir1dir2ralphabetas r:r!r!sO   t $E %#+ D ||CIs# txx~& ''rLc|j|}|j|}|j|s |jr|S|j| r| St d)zReturns the bending angle from `dir1` to `dir2` in radians. The normal vector is required to detect the bending orientation, an angle > 0 bends to the "left" an angle < 0 bends to the "right". zinvalid normal vector)rr/r2rzr=)rrr9anglenns r:r"r"sZ   t $E D B zz&RZZ VG v , --rLc`ddlm}||}tjt |dz S)z6Returns a vertex from the "inside" of the given face.r)mapbox_earcut_3dg@)ezdxf.math.triangulationr#r r>next)rOr#its r:any_vertex_inside_facer's): ( #B 88DH  ##rLr+cV dfd t|}t|}t||j| fd|D}t }|D]J}t |||d}|j |kDs+|j|jdLt|S)zReturns the count of intersections of the normal-vector of the given `face` with the `faces` in front of this `face`. A counter-clockwise vertex order is assumed! cLt|dkrytfd|DS)Nr)Fc3FK|]}j|kDywr)r)rr_r,detector_planes r:rzZfront_faces_intersect_face_normal..is_face_in_front_of_detector..s"T8a>44Q7'A8s!)r-any)rOr,r+s r:is_face_in_front_of_detectorzGfront_faces_intersect_face_normal..is_face_in_front_of_detectors# x=1 T8TTTrLc34K|]}|s |ywrr)rfr-s r:rz4front_faces_intersect_face_normal..sGe'CA'F1es Tr)rOSequence[Vec3]rr) rr'rrsetrraddroundr-) rIr3r, face_normalr front_facesintersection_pointsrr+r-s ` @@r:!front_faces_intersect_face_normalr8sU %T*K #D )F; (?@NHeGK &)U ( Kg  :   , ,R 07 : # #BHHQK 0 " ##rLc*t|||dzdk(S)aPReturns ``True`` if the face-normal for the given `face` of a closed surface is pointing outwards. A counter-clockwise vertex order is assumed, for faces with clockwise vertex order the result is inverted, therefore ``False`` is pointing outwards. This function does not check if the `faces` are a closed surface. r+r*r)r8)rIr3r,s r:r$r$s -UD' JQ NRS SSrLc,tdkr tddfd }t|jt|jt|j f}|j t||dkD}|}|r|dkDS|dkS)aReturns ``True`` when the given 3D vertices have a counter-clockwise order around the given normal vector. Works for convex and concave shapes. Does not check or care if all vertices are located in a flat plane or if the normal vector is really perpendicular to the shape, but the result may be incorrect in that cases. Args: vertices (list): corner vertices of a flat shape (polygon) normal (Vec3): normal vector of the shape Raises: ValueError: input has less than 3 vertices r)rNc\tj}dk(r|dddf|dddf}}n*dk(r|dddf|dddf}}n|dddf|dddf}}tj|tj|dtj|tj|dz S)Nrr<r*rR)nparrayrroll)rr`radomrOs r: signed_areaz+is_vertex_order_ccw_3d..signed_areas((8$ !81a4='!Q$-qA AX1a4='!Q$-qA1a4='!Q$-qAvvaB(266!RWWQ^+DDDrLrr)r-r=rr`rarbr5r)rOr9r@abs_axisccwdom_axisr?s` @r:r%r%s  8}q677 E688}c&((mS]:H ..X 'C -! Cc{H8a<0HqL0rLr)r3r1rr)T)r3r1rArrIterator[Sequence[Vec3]]))rIzIterable[Sequence[Vec3]]rrD)r6r r7r r8r rr )rOr1rr )rOzIterable[UVec]rr )rhr rir rjr rr)Tg|=) rsr1rtr1rurr,rrr))rrr)r<r<r<r)r|rrxrr}rrr )rIterable[Vec3]rrrz%tuple[Sequence[Vec3], Sequence[Vec3]])rir rjr rrFrr)rr rr rrFrr) rr rO list[Vec3]r9r rrr,r)rir rjr rintrrG)rr rr)rzSequence[UVec]rztuple[Vec3, float])rr rr rrrr)rr rr rr)rISequence[Sequence[Vec3]]r3r1rrH)rIrIr3r1rr)rOrGr9r rr)1 __future__rtypingrrrrenumrrfnumpyr<rqr r r r r rr__all__pirrrrrrrrrrrrrr#rrrrrrr r!r"r'r8r$r%rrLr:rPse#99  0 ggm:)-: :!%:::7 #77(, )(86      B      0 J/J/b  C7 C7 C7 + C7V  $ $ $$$X  " """"J   " ,0 <@ KP 5757p"   (28 . $  ($ #($ ($  ($^  T #T T  T"'1rL