h%SSKJr SSKJrJrJrJrJrJrJ r J r J r J r J r SSKJr SSKJrJrJrJrJrJrJrJrJrJrJrJrJr \ (aSSKJrJ r J!r!J"r" SSK#J$r$ \ "S5r%"SS \5r&\\'r(S \)S '\ \'\'4r*S \)S '\\*\&4r+S \)S '"SS\,5r-"SS\-5r."SS\-5r/"SS\-5r0"SS\-5r1SFSjr2SS.SGSjjr3SHSjr4SISjr5SJSjr6SKSjr7SLS jr8SMS!jr9SNS"jr:"S#S$5r;"S%S&5r<"S'S(\<5r=SOSPS*jjr>"S+S)\<5r?"S,S-\<5r@"S.S/5rASQSRS0jjrB\"SSS5rCSSS1jrDSTS2jrESUS3jrF"S4S55rGSVS6jrHSVS7jrISWS8jrJSXS9jrKSYS:jrLSZS;jrM"S<S=5rNS>SS?.S[S@jjrOS>SA.S\SBjjrPS]SCjrQS^S_SDjjrRS`SEjrSg>)a) annotations) DictIterableIterator NamedTupleOptionalSequence TYPE_CHECKINGTupleTypeTypeVarUnion) TypeAlias) BoundingBoxMatrix44NULLVECOCSUCSUVecVec3areais_planar_facenormal_vector_3psafe_normal_vectorsubdivide_facesubdivide_ngons)PolyfacePolymeshMeshSolid3d)GenericLayoutTypeTc.\rSrSr%SrS\S'S\S'Srg)EdgeStat)zNamed tuple of edge statistics.intcountbalanceN)__name__ __module__ __qualname____firstlineno____doc____annotations____static_attributes__r)C/var/www/html/env/lib/python3.13/site-packages/ezdxf/render/mesh.pyr$r$)s) J Lr1r$rFaceEdge EdgeStatsc\rSrSrSrg)MeshBuilderError5r)Nr*r+r,r-r0r)r1r2r7r75r1r7c\rSrSrSrg)NodeMergingError9r)Nr9r)r1r2r<r<9r:r1r<c\rSrSrSrg)MultipleMeshesError=r)Nr9r)r1r2r?r?=r:r1r?c\rSrSrSrg)DegeneratedPathErrorAr)Nr9r)r1r2rBrBAr:r1rBc\rSrSrSrg)NonManifoldMeshErrorEr)Nr9r)r1r2rErEEr:r1rEc#r# UH-n[U5S:aMUSUS:Xa USSv M)Uv M/ g7f)zfYields all faces with more than two vertices as open faces (first vertex index != last vertex index). rN)lenfacesfaces r2 open_facesrNIs? t9q=  7d2h s)OJ s57Fclosec## [U5HjnUS/nUSSHnUSU:wdMURU5 M! [U5S:aMBU(aURUS5 [U5v Ml g7f)zRemoves duplicated vertices and returns closed or open faces according the `close` argument. Returns only faces with at least 3 edges. rNrIrH)rNappendrJtuple)rLrPrMnew_faceindexs r2normalize_facesrWVsw5!G9!"XE|u$& x=1    OOHQK (Ho"s $A=AA=c#Z# [U5Hn[U5ShvN M gN 7f)z$Yields all face edges as int tuples.N)rN face_edgesrKs r2 all_edgesrZjs%5!d###"#s +) +c#f# [U5n[U5HnXXS-U-4v M g7f)z5Yields all edges of a single open face as int tuples.rRN)rJrange)rMsizerVs r2rYrYps5 t9Dtk4d 2333s/1c[SS5n0n[U5H:up4X44nSnX4:aXC4nSnURXQ5upx[US-X-5X%'M< U$)aReturns the edge statistics. The Edge statistic contains for each edge `(a, b)` the :class:`EdgeStat` as tuple `(count, balance)` where the vertex index `a` is always smaller than the vertex index `b`. The edge count is how often this edge is used in faces as `(a, b)` or `(b, a)` and the balance is the count of edge `(a, b)` minus the count of edge `(b, a)` and should be 0 in "healthy" closed surfaces. A balance not 0 indicates an error which may be double coincident faces or mixed face vertex orders. rrRrI)r$rZget) rLnew_edgestatsabedge orientationr'r(s r2get_edge_statsrfwsn1~HE% t 54DK42uqy'*?@ ! Lr1c^[T5nUS:Xag[R"T5U- nSnSnUHn[U5S:aM[U4SjU55n[R"U5[U5- n[ USUSUS5n X- R5n XYRU 5- nUS- nM US:aXT- $g![a Mf=f![ a Mf=f![ a Mf=f)a=Returns the estimated face-normals direction as ``float`` value in the range [-1.0, 1.0] for a closed surface. This heuristic works well for simple convex hulls but struggles with more complex structures like a torus (doughnut). A counter-clockwise (ccw) vertex arrangement is assumed but a clockwise (cw) arrangement works too but the values are reversed. The closer the value to 1.0 (-1.0 for cw) the more likely all normals pointing outwards from the surface. The closer the value to -1.0 (1.0 for cw) the more likely all normals pointing inwards from the surface. rrHc3.># UH nTUv M g7fNr).0iverticess r2 2estimate_face_normals_direction..s!# UHoRS:gv M g7f)rN)r(rles r2ro6MeshDiagnose.is_edge_balance_broken..<sD+Ca99>+C)anyrvaluesrs r2is_edge_balance_broken#MeshDiagnose.is_edge_balance_broken1s"D4??+A+A+CDDDr1cV[SURR555$)zReturns ``True`` if all edges have an edge count < 3. (cached data) A non-manifold mesh has edges with 3 or more connected faces. c3># UHoRS:v M g7f)rHNr'rlrds r2ro+MeshDiagnose.is_manifold..EsG.Fd::>.Frallrrrs r2 is_manifoldMeshDiagnose.is_manifold>s"Gdoo.D.D.FGGGr1cV[SURR555$)aReturns ``True`` if the mesh has a closed surface. This method does not require a unified face orientation. If multiple separated meshes are present the state is only ``True`` if **all** meshes have a closed surface. (cached data) Returns ``False`` for non-manifold meshes. c3># UHoRS:Hv M g7f)rrNrrs r2ro1MeshDiagnose.is_closed_surface..QsH/Gt::?/Grrrs r2is_closed_surfaceMeshDiagnose.is_closed_surfaceGs"Ht/E/E/GHHHr1cV[SURR555$)zReturns the total edge count of all faces, shared edges are counted separately for each face. In closed surfaces this count should be 2x the unique edge count :attr:`n_edges`. (cached data) c38# UHoRv M g7frjrrs r2ro0MeshDiagnose.total_edge_count..Xs=$.sW8V~d++8Vr)rrfaces_as_verticesrs r2has_non_planar_faces!MeshDiagnose.has_non_planar_facess#W 8T8T8VWWWWr1cUR(aBSnURRS5HnU[USUSUS5- nM US- $g)aReturns the volume of a closed surface or 0 otherwise. .. warning:: The face vertices have to be in counter-clockwise order, this requirement is not checked by this method. The result is not correct for multiple separated meshes in a single MeshBuilder object!!! rhrHrrRrrg@)rr tessellationr)rvolumerMs r2rMeshDiagnose.volumesW  ! !F //2'$q'47DG<<3C< r1cURnSnURR5H%nUVs/sHoAUPM nnU[U5- nM' U$s snf)zReturns the surface area.rh)rnrrNr)rv surface_arearMrmrs r2rMeshDiagnose.surface_areasY MM JJ))+D%)*TtTG* GG, ,L,+sAcURS:a-[R"UR5UR- $[$)z6Returns the centroid of all vertices. (center of mass)r)rxrrsrnrrs r2centroidMeshDiagnose.centroids/ ??Q 88DMM*T__< <r1)rrrrN)r MeshBuilder)returnSequence[Vec3])rSequence[Face]rr)rr&)rr5rbool)rIterable[Edge])rfloat)rr)r*r+r,r-rpropertyrnrLrrrxrrrrrrrrrrrrrrr0r)r1r2rrs#, ##  "" ""$$    == E EHH I I>&!JFX&r1rc\rSrSrSrS(SjrS)SjrSrS*SjrS+Sjr S,Sjr S-S jr S.S jr S/S jr S0S jrS1S jrS2S3SjjrS2S4SjjrS5S6Sjjr\S7Sj5r\S8Sj5rS2S4SjjrS9S:SjjrS2S4Sjjr\S;Sj5rSS?SjjrS@SASjjrSBSCSjjrSBSDSjjrSBSESjjrS(Sjr SFSjr!S(S jr"SGSHS!jjr#SS".SIS#jjr$SGS$SS%.SJS&jjjr%S'r&g)Kria@A simple Mesh builder. Stores a list of vertices and a faces list where each face is a list of indices into the vertices list. The :meth:`render_mesh` method, renders the mesh into a DXF MESH entity. The MESH entity supports ngons in AutoCAD, ngons are polygons with more than 4 vertices. Can only create new meshes. c /Ul/UlgrjrnrLrs r2rMeshBuilder.__init__s$& *, r1c,[UR5$)z9Returns the :class:`~ezdxf.math.BoundingBox` of the mesh.)rrnrs r2rMeshBuilder.bboxs4==))r1c$URU5$)zReturns a copy of mesh.) from_builderrs r2copyMeshBuilder.copys  &&r1c[U5$)z7Returns the :class:`MeshDiagnose` object for this mesh.)rrs r2diagnoseMeshBuilder.diagnoses D!!r1c`^URm[U4SjURU55$)zKReturns the face `index` as sequence of :class:`~ezdxf.math.Vec3` objects. c3.># UH nTUv M g7frjr))rlvirns r2ro0MeshBuilder.get_face_vertices..s>,=bXb\,=rq)rnrTrL)rrVrns @r2get_face_verticesMeshBuilder.get_face_verticess(==>DJJu,=>>>r1ctURU5n[U5$![[4a [s$f=f)zReturns the normal vector of the face `index` as :class:`~ezdxf.math.Vec3`, returns the ``NULLVEC`` instance for degenerated faces. )rr ValueErrorrur)rrVrMs r2get_face_normalMeshBuilder.get_face_normals>%%e, %d+ +-. N s 77c## UR5Hn[U5v M g![[4a [v M1f=f7f)zPYields all face normals, yields the ``NULLVEC`` instance for degenerated faces. N)rrr rur)rrMs r2rMeshBuilder.face_normalssE**,D (..- 12   s%A )AAAAAc## URnURHnUVs/sHo1UPM snv M gs snf7f)z%Yields all faces as list of vertices.Nr)rrrMrVs r2rMeshBuilder.faces_as_verticess6 MMJJD)-.U8. ..s ?:?c#J# [UR5ShvN gN7f)zhYields all faces as sequence of integers where the first vertex is not coincident with the last vertex. N)rNrLrs r2rNMeshBuilder.open_facessdjj)))s #!#cXURRURU55 g)aKAdd a face as vertices list to the mesh. A face requires at least 3 vertices, each vertex is a ``(x, y, z)`` tuple or :class:`~ezdxf.math.Vec3` object. The new vertex indices are stored as face in the :attr:`faces` list. Args: vertices: list of at least 3 vertices ``[(x1, y1, z1), (x2, y2, z2), (x3, y3, y3), ...]`` N)rLrS add_vertices)rrns r2add_faceMeshBuilder.add_faces! $++H56r1c[UR5nURR[R"U55 [ [ U[UR555$)a Add new vertices to the mesh, each vertex is a ``(x, y, z)`` tuple or a :class:`~ezdxf.math.Vec3` object, returns the indices of the `vertices` added to the :attr:`vertices` list. e.g. adding 4 vertices to an empty mesh, returns the indices ``(0, 1, 2, 3)``, adding additional 4 vertices returns the indices ``(4, 5, 6, 7)``. Args: vertices: list of vertices, vertex as ``(x, y, z)`` tuple or :class:`~ezdxf.math.Vec3` objects Returns: tuple: indices of the `vertices` added to the :attr:`vertices` list )rJrnextendrgeneraterTr\)rrn start_indexs r2rMeshBuilder.add_verticessH"$--(  T]]845U;DMM(:;<# UH nTUv M g7frjr))rlrindicess r2ro'MeshBuilder.add_mesh..+s#H-BGBK-rq) rrrnrLr rrNrSrT)rrnrLrr{rs @r2add_meshMeshBuilder.add_meshs}&  yy/HJJE  AB B ##H-'.M JJ  e#H-#HH I/r1c^U(a [U5O0nURnUbURU5nUbURU5nUR US9nUR 5n[ U5Ul[ UR5UlSSS5 U$!,(df  U$=f)a]Render mesh as :class:`~ezdxf.entities.Mesh` entity into `layout`. Args: layout: :class:`~ezdxf.layouts.BaseLayout` object dxfattribs: dict of DXF attributes e.g. ``{'layer': 'mesh', 'color': 7}`` matrix: transformation matrix of type :class:`~ezdxf.math.Matrix44` ucs: transform vertices by :class:`~ezdxf.math.UCS` to :ref:`WCS` N dxfattribs)dictrntransform_vertices points_to_wcsr edit_datarrL)rlayoutr#matrixucsrnrdatas r2 render_meshMeshBuilder.render_mesh-s *4T*% ==  00:H ?((2H*5 ^^ !NDMdjj)DJ      s (+B B,cTU(a [U5O0nUR5Hon[U5nUS:aM[R"U5U- n[ U5nU(aUSU- RU-n OUn URXwX--US9 Mq g![ a Mf=f)aRender face normals as :class:`~ezdxf.entities.Line` entities into `layout`, useful to check orientation of mesh faces. Args: layout: :class:`~ezdxf.layouts.BaseLayout` object length: visual length of normal, use length < 0 to point normals in opposite direction relative: scale length relative to face size if ``True`` dxfattribs: dict of DXF attributes e.g. ``{'layer': 'normals', 'color': 6}`` rHrr"N) r$rrJrrsrru magnitudeadd_line) rr(lengthrelativer#rMr'centern_lengths r2render_normalsMeshBuilder.render_normalsKs$*4T*% **,DIEqyXXd^e+F &t,7V+66?  OOFQ[$8ZO P-%  s B B'&B'c`U"5n[U[5(deURUS9 U$)aCreate new mesh from other mesh as class method. Args: other: `mesh` of type :class:`MeshBuilder` and inherited or DXF :class:`~ezdxf.entities.Mesh` entity or any object providing attributes :attr:`vertices`, :attr:`edges` and :attr:`faces`. r) isinstancerrclsotherrs r2 from_meshMeshBuilder.from_meshms1u$ ,,,, 5 ! r1c UR5S:wa[SUR535eU"5n[U[5(deUR(a<UR 5up4UH"nUR UR55 M$ U$UR(aUR5n[URRS- 5H]n[URRS- 5H4nUR XgU4XgUS-4XgS-US-4XgS-U445 M6 M_ U$[S5e)zhCreate new mesh from a :class:`~ezdxf.entities.Polyface` or :class:`~ezdxf.entities.Polymesh` object. POLYLINEzUnsupported DXF type: rRzNot a polymesh or polyface.)dxftype TypeErrorr:ris_poly_face_mesh indexed_facesrpointsis_polygon_meshget_mesh_vertex_cacher\dxfm_countn_count) r<r=r_rLrMrnmr4s r2 from_polyfaceMeshBuilder.from_polyface}s4 ==?j (4U]]_4EFG Gu$ ,,,,  " "**,HA dkkm,   " "224H599,,q01uyy00145AMM$TN$AX.$UAE\2$UAX. 62 9: :r1cU(a [U5O0nURUS9n[RU5nUbUR U5 UbUR UR 5 UR URSS9US9 U$)aaRender mesh as :class:`~ezdxf.entities.Polyface` entity into `layout`. Args: layout: :class:`~ezdxf.layouts.BaseLayout` object dxfattribs: dict of DXF attributes e.g. ``{'layer': 'mesh', 'color': 7}`` matrix: transformation matrix of type :class:`~ezdxf.math.Matrix44` ucs: transform vertices by :class:`~ezdxf.math.UCS` to :ref:`WCS` r"max_vertex_count)r$ add_polyfaceMeshTransformerr transformr) append_facesr)rr(r#r)r*polyfacets r2render_polyfaceMeshBuilder.render_polyfaces"*4T*% &&*&=  ( ( .   KK  ? KK # NNAN .!  r1cSSKJn U(a [U5O0nURUS9nUR U5nUR XE/5 U$)aRender mesh as :class:`~ezdxf.entities.Solid3d` entity into `layout`. This is an **experimental** feature to create simple 3DSOLID entities from polyhedrons. The method supports closed and open shells. A 3DSOLID entity can contain multiple shells. Separate the meshes beforehand by the method :meth:`separate_meshes` if required. The normals vectors of all faces should point outwards. Faces can have more than 3 vertices (ngons) but non-planar faces and concave faces will cause problems in some CAD applications. The method :meth:`mesh_tesselation` can help to break down the faces into triangles. Requires a valid DXF document for `layout` and DXF version R2000 or newer. Args: layout: :class:`~ezdxf.layouts.BaseLayout` object dxfattribs: dict of DXF attributes e.g. ``{'layer': 'mesh', 'color': 7}`` Raises: DXFValueError: valid DXF document required, if :attr:`layout.doc` is ``None`` DXFVersionError: invalid DXF version .. versionadded:: 1.2.0 r)apir") ezdxf.acisr]r$ add_3dsolidbody_from_mesh export_dxf)rr(r#acissolid3dbodys r2render_3dsolidMeshBuilder.render_3dsolidsK4 +)3T*% $$ $;""4( (r1cU(a [U5O0n[RU5nUbURU5 UbURUR5 UR SS9HnUR XbS9 M g)aaRender mesh as :class:`~ezdxf.entities.Face3d` entities into `layout`. Args: layout: :class:`~ezdxf.layouts.BaseLayout` object dxfattribs: dict of DXF attributes e.g. ``{'layer': 'mesh', 'color': 7}`` matrix: transformation matrix of type :class:`~ezdxf.math.Matrix44` ucs: transform vertices by :class:`~ezdxf.math.UCS` to :ref:`WCS` NrQrRr")r$rUrrVr)r add_3dface)rr(r#r)r*rYrMs r2render_3dfacesMeshBuilder.render_3dfacesso"*4T*%  ( ( .   KK  ? KK #NNAN6D   d  :7r1cU"5n[U[5(de[UR5Ul[UR5UlU$)zCreate new mesh from other mesh builder, faster than :meth:`from_mesh` but supports only :class:`MeshBuilder` and inherited classes. )r:rrrnrLr;s r2rMeshBuilder.from_buildersEu$ ,,,,U^^, %++&  r1cUn[U5H#n[URUR5nM% [R U5$)zReturns a new :class:`MeshBuilder` object with merged adjacent coplanar faces. The faces have to share at least two vertices and have to have the same clockwise or counter-clockwise vertex order. The current implementation is not very capable! )r\_merge_adjacent_coplanar_facesrnrLrUr)rpassesrrLs r2merge_coplanar_faces MeshBuilder.merge_coplanar_facess<vA1$--LD++D11r1cUn[[U5S5nUS:a[X25nUS-nUS:aM[R U5$)zReturns a new :class:`MeshTransformer` object with all faces subdivided. Args: level: subdivide levels from 1 to max of 5 quads: create quad faces if ``True`` else create triangles rrR)minr& _subdividerUr)rlevelquadsrs r2 subdivideMeshBuilder.subdividesOCJ"aid*D QJEai++D11r1c\[US9nURUS9 [RU5$)zReturns a new mesh with optimized vertices. Coincident vertices are merged together and all faces are open faces (first vertex != last vertex). Uses internally the :class:`MeshVertexMerger` class to merge vertices. ) precisionr9)MeshVertexMergerrrUr)rr{rs r2optimize_verticesMeshBuilder.optimize_vertices#s-  )4 4  ++D11r1c#T# [UR5U5ShvN gN7f)a[Yields all faces as sequence of :class:`~ezdxf.math.Vec3` instances, where all ngons which have more than `max_vertex_count` vertices gets subdivided. In contrast to the :meth:`tessellation` method, creates this method a new vertex in the centroid of the face. This can create a more regular tessellation but only works reliable for convex faces! N)rr)rrSs r2rMeshBuilder.subdivide_ngons-s!#4#9#9#;=MNNNs (&(c## SSKJn UR5H(n[U5U::aUv MU"U5ShvN M* gN 7f)aYields all faces as sequence of :class:`~ezdxf.math.Vec3` instances, each face has no more vertices than the given `max_vertex_count`. This method uses the "ear clipping" algorithm which works with concave faces too and does not create any additional vertices. r)mapbox_earcut_3dN)ezdxf.math.triangulationrrrJ)rrSrrMs r2rMeshBuilder.tessellation7sB >**,D4y,, +D111 -2s:AA Ac[5nURUS9HnURU5 M [R U5$)zReturns a new :class:`MeshTransformer` instance, where each face has no more vertices than the given `max_vertex_count`. The `fast` mode uses a shortcut for faces with less than 6 vertices which may not work for concave faces! rR)r|rrrUr)rrSrrMs r2mesh_tessellationMeshBuilder.mesh_tessellationEsC !%%7G%HD MM$ I++D11r1cJ[[UR55Ulg)zEFlips the normals of all faces by reversing the vertex order inplace.N)rrrLrs r2 flip_normalsMeshBuilder.flip_normalsQs+DJJ78 r1c*[[U55$)zA single :class:`MeshBuilder` instance can store multiple separated meshes. This function returns this separated meshes as multiple :class:`MeshTransformer` instances. )rseparate_meshesrs r2rMeshBuilder.separate_meshesUs OD)**r1cH[[URSS95Ulg)zRemoves duplicated vertex indices from faces and stores all faces as open faces, where the last vertex is not coincident with the first vertex. FrON)rrWrLrs r2rWMeshBuilder.normalize_faces\s /$**EBC r1c[XS9$)aNReturns a :class:`FaceOrientationDetector` or short `fod` instance. The forward orientation is defined by the `reference` face which is 0 by default. The `fod` can check if all faces are reachable from the reference face and if all faces have the same orientation. The `fod` can be reused to unify the face orientation of the mesh.  reference)FaceOrientationDetector)rrs r2face_orientation_detector%MeshBuilder.face_orientation_detectorcs'tAAr1fodc[XS9$)apReturns a new :class:`MeshTransformer` object with unified face normal vectors of all faces. The forward direction (not necessarily outwards) is defined by the face-normals of the majority of the faces. This function can not process non-manifold meshes (more than two faces are connected by a single edge) or multiple disconnected meshes in a single :class:`MeshBuilder` object. It is possible to pass in an existing :class:`FaceOrientationDetector` instance as argument `fod`. Raises: NonManifoldError: non-manifold mesh MultipleMeshesError: the :class:`MeshBuilder` object contains multiple disconnected meshes r)unify_face_normals_by_majority)rrs r2unify_face_normalsMeshBuilder.unify_face_normalsos&.d<[XUS9nU(a [XA5 U$)aReturns a new :class:`MeshTransformer` object with unified face normal vectors of all faces. The forward direction (not necessarily outwards) is defined by the reference face, which is the first face of the `mesh` by default. This function can not process non-manifold meshes (more than two faces are connected by a single edge) or multiple disconnected meshes in a single :class:`MeshBuilder` object. The outward direction of all face normals can be forced by stetting the argument `force_outwards` to ``True`` but this works only for closed surfaces, and it's time-consuming! It is not possible to check for a closed surface as long the face normal vectors are not unified. But it can be done afterward by the attribute :meth:`MeshDiagnose.is_closed_surface` to see if the result is trustworthy. It is possible to pass in an existing :class:`FaceOrientationDetector` instance as argument `fod`. Args: reference: index of the reference face force_outwards: forces face-normals to point outwards, this works only for closed surfaces, and it's time-consuming! fod: :class:`FaceOrientationDetector` instance Raises: ValueError: non-manifold mesh or the :class:`MeshBuilder` object contains multiple disconnected meshes )rr)unify_face_normals_by_reference%_force_face_normals_pointing_outwards)rrrrrs r2r+MeshBuilder.unify_face_normals_by_references!L/tcR  1$ B r1)rLrn)rNoner)rr)rVr&rr)rVr&rr)rIterator[Vec3])rzIterator[list[Vec3]]rIterator[Face])rnIterable[UVec]rrrnrrr3)NNN)rnzOptional[list[Vec3]]rLzOptional[list[Face]]rr)r(r!r)zOptional[Matrix44]r*z Optional[UCS])rRTN)r(r!r1r)r<Type[T]r=zUnion[MeshBuilder, Mesh]rr")r<rr=zUnion[Polymesh, Polyface]rr"rj)r(r!rr )r<rr=rrr")rR)ror&rrU)rRT)rvr&rrU)r{r&rrUrQ)rIterator[Sequence[Vec3]])rSr&rr)rSr&rrU)rzlist[MeshTransformer]r)rr&rr)r!Optional[FaceOrientationDetector]rrU)rr&rrrrU)'r*r+r,r-r.rrrrrr rrrNrrrr,r6 classmethodr>rNrZrerirrprxr}rrrrrrWrrrr0r)r1r2rrs - *'"?/ * 7=.*.&*  J&J$J  JD%)! !#   B Q! Q QD  B%)! !#   < J%)! ;!;# ;  ;4   2 22O 2 29+D B;?=7= =.)15 )) / )  ))r1rcp\rSrSrSrS SjrSSSjjrSSSjjrSSjrSSjr SSjr SS jr SS jr S r g )rUiz3A mesh builder with inplace transformation support.cX[URUR55UlU$)zTransform mesh inplace by applying the transformation `matrix`. Args: matrix: 4x4 transformation matrix as :class:`~ezdxf.math.Matrix44` object )rr%rn)rr)s r2rVMeshTransformer.transforms$V66t}}EF  r1c[U[[45(a [XU5nO [U5nURVs/sHoTU-PM snUlU$s snf)zTranslate mesh inplace. Args: dx: translation in x-axis or translation vector dy: translation in y-axis dz: translation in z-axis )r:rr&rrn)rdxdydzrYrs r2 translateMeshTransformer.translatesP b5#, ' 'RR ARA(, 6 1Q 6  7sAc URVVVs/sHupEn[XA-XR-Xc-5PM snnnUlU$s snnnf)z|Scale mesh inplace. Args: sx: scale factor for x-axis sy: scale factor for y-axis sz: scale factor for z-axis )rnr)rsxsyszrrrs r2scaleMeshTransformer.scales>FJ]]S]'!afafaf5]S  Ts =cXURVs/sHo"U-PM snUlU$s snf)zNScale mesh uniform inplace. Args: s: scale factor for x-, y- and z-axis rn)rsrs r2 scale_uniformMeshTransformer.scale_uniforms*)- 6 1Q 6  7s'c[[R"U5RUR55UlU$)z^Rotate mesh around x-axis about `angle` inplace. Args: angle: rotation angle in radians )rrx_rotater%rnrangles r2rotate_xMeshTransformer.rotate_x/X..u5HHWX  r1c[[R"U5RUR55UlU$)z^Rotate mesh around y-axis about `angle` inplace. Args: angle: rotation angle in radians )rry_rotater%rnrs r2rotate_yMeshTransformer.rotate_yrr1c[[R"U5RUR55UlU$)z^Rotate mesh around z-axis about `angle` inplace. Args: angle: rotation angle in radians )rrz_rotater%rnrs r2rotate_zMeshTransformer.rotate_zrr1c[[R"X5RUR55UlU$)zRotate mesh around an arbitrary axis located in the origin (0, 0, 0) about `angle`. Args: axis: rotation axis as Vec3 angle: rotation angle in radians )rr axis_rotater%rn)raxisrs r2 rotate_axisMeshTransformer.rotate_axiss4   - @ @ O   r1rN)r)r)rrr)rzUnion[float, UVec]rrrr)rRrRrR)rrrrrr)rr)rr)rrrr)r*r+r,r-r.rVrrrrrrrr0r)r1r2rUrUs-=   r1rUr|c[5nUR5H7n[U5S:aM[X15HnUR U5 M M9 U$)zReturns a new :class:`MeshVertexMerger` object with subdivided faces and edges. Args: quads: create quad faces if ``True`` else create triangles rH)r|rrJrr)rrwnew_meshrnrMs r2rurusR !H**, x=1  "83D   d #4- Or1c\^\rSrSrSrSS U4SjjjrS SjrS Sjr\S Sj5r Sr U=r $) r|i"aSubclass of :class:`MeshBuilder` Mesh with unique vertices and no doublets, but needs extra memory for bookkeeping. :class:`MeshVertexMerger` creates a key for every vertex by rounding its components by the Python :func:`round` function and a given `precision` value. Each vertex with the same key gets the same vertex index, which is the index of first vertex with this key, so all vertices with the same key will be located at the location of this first vertex. If you want an average location of all vertices with the same key use the :class:`MeshAverageVertexMerger` class. Args: precision: floating point precision for vertex rounding c<>[TU]5 0UlXlg)zD Args: precision: floating point precision for vertex rounding Nsuperrledgerr{rr{ __class__s r2rMeshVertexMerger.__init__6s ') 'r1c/nURn[R"U5H3nURU5nUR UR U5 M5 [U5$![ aS [UR5nURR U5 X`R U'UR U5 Mf=f)aIAdd new `vertices` only, if no vertex with identical (x, y, z) coordinates already exist, else the index of the existing vertex is returned as index of the added vertices. Args: vertices: list of vertices, vertex as (x, y, z) tuple or :class:`~ezdxf.math.Vec3` objects Returns: indices of the added `vertices` ) r{rrroundrSrKeyErrorrJrnrT)rrnrr{vertexkeyrVs r2rMeshVertexMerger.add_vertices@sNN mmH-F,,y)C &t{{3/0.W~  &DMM* $$V,#( C u%  &sA''ACCcUR[U5RUR5$![a [ S[ U5S35ef=f)Get index of `vertex`, raises :class:`IndexError` if not found. Args: vertex: ``(x, y, z)`` tuple or :class:`~ezdxf.math.Vec3` object (internal API) Vertex not found.rrrr{rrtstrrrs r2rVMeshVertexMerger.indexZsS A;;tF|11$..AB B Aws6{m;?@ @ As 03#Ac$URU5$z(Create new mesh from other mesh builder.r>r<r=s r2rMeshVertexMerger.from_builderg}}U##r1rr{rr{r&rrrrr&)r=rrr| r*r+r,r-r.rrrVrrr0 __classcell__rs@r2r|r|"s1&((4 A$$r1c\^\rSrSrSrSS U4SjjjrS SjrS Sjr\S Sj5r Sr U=r $) MeshAverageVertexMergerina2Subclass of :class:`MeshBuilder` Mesh with unique vertices and no doublets, but needs extra memory for bookkeeping and runtime for calculation of average vertex location. :class:`MeshAverageVertexMerger` creates a key for every vertex by rounding its components by the Python :func:`round` function and a given `precision` value. Each vertex with the same key gets the same vertex index, which is the index of first vertex with this key, the difference to the :class:`MeshVertexMerger` class is the calculation of the average location for all vertices with the same key, this needs extra memory to keep track of the count of vertices for each key and extra runtime for updating the vertex location each time a vertex with an existing key is added. Args: precision: floating point precision for vertex rounding c<>[TU]5 0UlXlgrjrrs r2r MeshAverageVertexMerger.__init__s!   (r1c/nURn[R"U5HrnURU5nURUupgUR UU-U-nUS- nX- UR U'Xg4URU'URU5 Mt [U5$![ aD [UR 5nUR RU5 US4URU'Nmf=f)aAdd new `vertices` only, if no vertex with identical ``(x, y, z)`` coordinates already exist, else the index of the existing vertex is returned as index of the added vertices. Args: vertices: list of vertices, vertex as ``(x, y, z)`` tuple or :class:`~ezdxf.math.Vec3` objects Returns: tuple: indices of the `vertices` added to the :attr:`~MeshBuilder.vertices` list rR) r{rrrrrnrrJrSrT) rrnrr{rrrVr'averages r2r$MeshAverageVertexMerger.add_verticessNN mmH-F,,y)C 2#{{3/  ==/%76A '. e$$)> C NN5 !!."W~ .DMM* $$V,$)1: C  .sB&&A C43C4cUR[U5RUR5S$![a [ S[ U5S35ef=f)rrrrrrs r2rVMeshAverageVertexMerger.indexsX A;;tF|11$..AB1E E Aws6{m;?@ @ As 36#Ac$URU5$rrrs r2r$MeshAverageVertexMerger.from_builderrr1rrrrr)r=rrrrrs@r2rrns2(((!F A$$r1rc0\rSrSrSrSSjrSS SjjrSrg) _XFacei) fingerprintr _orientationcF[U5UlXl[Ulgrj)hashrr VEC3_SENTINELr )rrs r2r_XFace.__init__s $W $ "/r1cUR[LaR[nURVs/sHoAUPM sntpVnUHn[ XVU5R U5n O X0lUR$s snf![ a MGf=frj)r r rrrrru) rrnr{rermv0v1rv2s r2re_XFace.orientations    -!K/3||<|!1+|"D"DY"OK !,    = )sA2A77 BB)r rrN)rr3r)rnrr{r&rr)r*r+r,r- __slots__rrer0r)r1r2rrs:I0 ! !r1rc 0n/nUHin[U5S:a [S5e[U5nURU5 UR UR X5/5RU5 Mk [ 5n[5nUGHYnURU;aMURUR5 URnUR X5n X9n [U5n U Hn U RU;aMU R[U R55n [U 5S:dMJ[U 5[U R5:Xa[X\R5nO[X\R5nURU R5 [U5n M [![#UVs/sHoUPM sn55nUR%U5 GM\ U$![[4a GMf=fs snf)NrHzfound invalid face count < 3rR)rJr rrS setdefaultrer|setraddr intersectionmerge_full_patchmerge_connected_pathsr<rBrremove_colinear_face_verticesr)rnrLr{oriented_facesextended_facesrMxfacerdonereparallel_facesface_set parallel_facecommon_verticesrmrs r2rnrns02N#%N t9q=;< <t e$!!%"3"3H"H"MTT    D 5D    $  ""#}}''< '4t9+M((D0&33C 8M8M4NOO?#a''3}/D/D+EE+D2G2GHD!4T;P;PQ223t9,/d0Kd!d0KL M b1 2 K -.BC! !1Ls,G*9H*G?>G?c## S Sjn[U5S:a UShvN gUS/nUSSH/nURUS5(aMURU5 M1 [U5S:a.[U5S:XaURUS5 UShvN gUSn[n[nSnUv U[LaUS- nXnU"XE5nU[LaMSnURU5 X'SH7n U"XI5RU5(aU nM$Uv SnUnU"XI5nU nM9 U(dUSv ggGN N![a Uv gf=f![ a Mqf=f7f) Nc&X- R5$rj)rv)rrs r2 get_direction4remove_colinear_face_vertices..get_directions""$$r1rHrrRrIFT)rrrr)rJiscloserSr rtru) rnr& _verticesrstart prev_vertexcurrent_directionryielded_anythingrs r2rrs% 8}q&a[MI ab\yy2''   Q  9~ y>Q    Yq\ * aLEK%K K } ,q  "/K*%= } , UL) U+334EFF$ G )%8 * m ]      !   svE&D<*E& A E&D?*E&EE&E&5E*E&?E&EE&EE& E#E&"E##E&cSSjnU"U5nU"U5nUSnUSnU/nX5nX;aXCpCX:XaO UnXW;a[eURU5 M2[U5S:a[eU$![a [ef=f)Ncj[XSS5VVs0sHupX_M nnnUSX0S'U$s snnf)NrRrrI)zip)pe1e2nodess r2 build_nodes*merge_connected_paths..build_nodes>s=&)!qrUm4mFBm4te  5s/rrH)r2 Sequence[int])rr<rSrJrB) p1p2r6 current_path other_path current_nodefinishconnected_path next_nodes r2rr=s r?LRJa5L UF"^N  #$2I  "'1*     )# "l+   >Q""  #" " #s A--A>c[U5n/n[U5H3upEXS- nXS-U-nXa;aXq;aM"URU5 M5 U$)NrR)rJ enumeraterS)pathpatchr'new_pathposnodeprevsuccs r2rr]s[ IEHt_ !G}1W%& =T]  % Or1c2\rSrSrSSjrSSjrS SjrSrg) Lumpiic[5UlU/Ul[U5H)up#URR X#::aX#4OX245 M+ grj)redgesrLrYr)rrMrbrcs r2r Lump.__init__js? # "& t$DA JJNNQVA6! 8%r1cVURRUR5(+$rj)rM isdisjointrr=s r2 is_connectedLump.is_connectedqs::((555r1cURRUR5 URRUR5 grj)rLrrMupdaterQs r2merge Lump.mergets. %++& %++&r1)rMrLN)rMr3)r=rKrr)r=rK)r*r+r,r-rrRrVr0r)r1r2rKrKis96'r1rKc[U5nSnS[U5s=:aU:wa6O U$[U5n[U5nS[U5s=:a U:waM.U$ U$)NrrR) _merge_lumpsrJ)lumps merged_lumps prior_lens r2 merge_lumpsr]ysj&LI c, ,9 ,  % #L1  c, ,9 ,  - r1c/nUHGnUH-nURU5(dMURU5 M4 URU5 MI U$rj)rRrVrS)rZr[lumpbases r2rYrYsS!L D  && 4 !    %  r1c#^# [[S[UR5555n[ U5S:aeUR mUHRn[ 5nURHnURU4SjU55 M [RU5v MT g[RU5v g7f)zwReturns the separated meshes in a single :class:`MeshBuilder` instance as multiple :class:`MeshTransformer` instances. c38# UHn[U5v M g7frj)rKrs r2ro"separate_meshes..s)UAT$t**ATrrRc3.># UH nTUv M g7frjr)rks r2rorcs84ahqk4rqN) rr]rNrLrJrnr|rrUr)rMdisconnected_lumpsr_rrMrns @r2rrs k)UAGGAT)UUV "::&D#%D  8488#!..t4 4 ' **1--sB;B>cJ[R"U5[U5- n[R"U5[U5- n[USUSUS5S-n[USUSUS5S-nX$-nX5-nUR U5nUR U5n X:$)zReturns ``True`` if the normals of the two faces are pointing away from the center of the two faces. .. warning:: This does not work for any arbitrary face pair! rrRrrg?)rrsrJrdistance) f0f1c0c1n0n1e0r3d0d1s r2have_away_pointing_normalsrqs "B B "B B "Q%A1 . 4B "Q%A1 . 4B B B RB RB 7Nr1c~SSKJn U"S5RU5nUR5un pE[ X55$)aReturns the state of face-normals of the unit-cube after the transformation `m` was applied. - ``True``: face-normals pointing outwards - ``False``: face-normals pointing inwards The state before the transformation is outward-pointing face-normals. rR)cubeT)formsrsrVrrq)rMrs unit_cubebottomrLtops r2!face_normals_after_transformationrxs?T $$Q'I'99;FAq!Q %f 22r1c0nUH6n[U5H$nURU/5RU5 M& M8 U$rj)rYrrS)rLmappingrMrds r2_make_edge_mappingr{sB&(Gt$D   tR ( / / 5% Nr1c\rSrSrSrSSSjjr\SSj5r\SSj5r\SSj5r \SSj5r \SSj5r \SS j5r SSS jjr \SS j5rSS jrS rg)ria Helper class for face orientation and face normal vector detection. Use the method :meth:`MeshBuilder.face_orientation_detector` to create an instance. The face orientation detector classifies the faces of a mesh by their forward or backward orientation. The forward orientation is defined by a reference face, which is the first face of the mesh by default and this orientation is not necessarily outwards. This class has some overlapping features with :class:`MeshDiagnose` but it has a longer setup time and needs more memory than :class:`MeshDiagnose`. Args: mesh: source mesh as :class:`MeshBuilder` object reference: index of the reference face cXl[UR5UlX lSUl[ 5Ul[ 5UlURU5 g)NT) rr{rL edge_mappingrrr$forwardbackwardclassify_faces)rrrs r2r FaceOrientationDetector.__init__sE 4Ftzz4R"(, )-  I&r1c2[UR5S:H$)z^Returns ``True`` if all reachable faces are forward oriented according to the reference face. r)rJrrs r2has_uniform_face_normals0FaceOrientationDetector.has_uniform_face_normalss 4==!Q&&r1cl[URR5[UR5:H$)zmReturns ``True`` if all faces are reachable from the reference face same as property :attr:`is_single_mesh`. )rJrrLrsr'rs r2 all_reachable%FaceOrientationDetector.all_reachables& 4::##$DJJ77r1cUR$)zZReturns ``True`` if only a single mesh is present same as property :attr:`all_reachable`. )rrs r2is_single_mesh&FaceOrientationDetector.is_single_meshs !!!r1cV[UR5[UR54$)z9Returns the count of forward and backward oriented faces.)rJrrrs r2r'FaceOrientationDetector.counts!4<< #dmm"444r1cH[URR55$)z"Yields all forward oriented faces.)iterrrrs r2 forward_faces%FaceOrientationDetector.forward_facessDLL'')**r1cH[URR55$)z#Yields all backward oriented faces.)rrrrs r2backward_faces&FaceOrientationDetector.backward_faces sDMM((*++r1c^^^^ ^ ^ SU 4SjjnSU4SjjnS UU U 4SjjmS UU U4Sjjn[U5TlSTlTRm [ 5m [ 5mTR R US4/m [T 5(aET RS5upVU(a U"U5 OU"U5 U"XV5 [T 5(aMET Tl TTl g) zDetect the forward and backward oriented faces. The forward and backward orientation has to be defined by a `reference` face. c">UT[U5'grjid)frs r2 add_forward;FaceOrientationDetector.classify_faces..add_forwardsGBqENr1c">UT[U5'grjr)rrs r2 add_backward.add_backwardsHRUOr1c\>[U5nUT;aUT;aTRX45 gggrj)rrS)rrerrr process_facess r2add_face_to_processCFaceOrientationDetector.classify_faces..add_face_to_processs4Q%C'!c&9$$a%56':!r1c>[U5HenTUn[U5S:aUHnX@LaM T"XA(+5 M TUSUS4n[U5S:XaT"USU5 M^STlMg g![a Mwf=f)NrRrF)rYrJrr)rrerd linked_faces linked_facerr~rs r2#add_adjacent_faces_to_process_queueSFaceOrientationDetector.classify_faces..add_adjacent_faces_to_process_queue#s"1 +D1 |$q('3 &+$+KI(4 #/Qa0@#AL|$)' QE(-D$)& s A77 BBTrN)rr3)rr3rer) r&rrr~r$rrLrJpoprr) rrrrrrMface_orientationrrr~rrs ` @@@@@r2r&FaceOrientationDetector.classify_facess   7 7  - -.Y(( #'6$(F37::3C3CI3NPT2U1V -  %2%6%6q%9 "DD!T" / G-     r1cUR(dg/nURnUR5HLnURX15nUSUS4nURXQ5n[ U5[ U5-S:wdML g g)aReturns ``True`` if the mesh has a closed surface. This method does not require a unified face orientation. If multiple separated meshes are present the state is only ``True`` if **all** meshes have a closed surface. Returns ``False`` for non-manifold meshes. FrRrrrT)rr~rr_rJ)remptyr~rdforward_connected_faces reversed_edgebackward_connected_facess r2r)FaceOrientationDetector.is_closed_surfaceMs((  %%'D&2&6&6t&C # GT!W,M'3'7'7 'M $*+c2J.KKqP ( r1cSSKJn [URR 55nX R nU"X#5$)zReturns ``True`` if the normal vector of the reference face is pointing outwards. This works only for meshes with unified faces which represent a closed surfaces, and it's a time-consuming calculation! r is_face_normal_pointing_outwards) ezdxf.mathrrrrr)rrrLreference_faces r2#is_reference_face_pointing_outwards;FaceOrientationDetector.is_reference_face_pointing_outwardsds6 @TZZ1134~~./FFr1)rrr~rrrNr)rrrr&r)rztuple[int, int]r)rr&rr)r*r+r,r-r.rrrrrr'rrrrrr0r)r1r2rrs$''' 88 "" 55++,,:!x, Gr1rN)rrc@Uc [X5nSSjn[XU5$)aeUnifies the orientation of all faces of a :class:`MeshBuilder` object. The forward orientation is defined by a reference face, which is the first face of the `mesh` by default. This function can not process non-manifold meshes (more than two faces are connected by a single edge) or multiple disconnected meshes in a single :class:`MeshBuilder` object. Returns always a copy of the source `mesh` as :class:`MeshTransformer` object. Args: mesh: source :class:`MeshBuilder` object fod: an already created :class:`FaceOrientationDetector` instance or ``None`` to create one internally. reference: index of the reference face for the internally created :class:`FaceOrientationDetector` instance Raises: NonManifoldError: non-manifold mesh MultipleMeshesError: :class:`MeshBuilder` object contains multiple disconnected meshes cUR$rj)r)detectors r2backward_selector:unify_face_normals_by_reference..backward_selectors   r1rrr_unify_face_normals)rrrrs r2rrqs(6 {%d6! t*; <.backward_selectors)!$*$4x  J(:J:JJr1rr)rrrs r2rrs)2 {%d+K t*; <23 U4[)   Odjj) Or1cSSKJn [UR55nX1nU"X45(dUR 5 gg)zDetect the orientation of the reference face and flip all face normals if required. Requirements: all face normals have to be unified and the mesh has a closed surface rrN)rrrrr)rrrrLrs r2rrs?< '') *E%N +E B B  Cr1cUR5nUR5 URSS9nUR(d [ S5eUR (d&[ [U55SnURSS9nUR(d[XS9nUR5nUR(a%UR5(dUR5 U$)aVReturns a new mesh with these properties: - one mesh: removes all meshes except the first mesh starting at the first face - optimized vertices: merges shared vertices - normalized faces: removes duplicated face vertices and faces with less than 3 vertices - open faces: all faces are open faces where first vertex != last vertex - unified face-orientation: all faces have the same orientation (ccw or cw) - ccw face-orientation: all face-normals are pointing outwards if the mesh has a closed surface Raises: NonManifoldMeshError: non-manifold mesh rrrr) r}rWrrrErrrrrrrr)rrrs r2normalize_meshrs"%%'H   , ,q , 9C ??"#677   12150010=  ' '28E002 S%L%L%N%N Or1)rLIterable[Face]rr)rLzlist[Sequence[int]]rIterator[Sequence[int]])rLrrzIterator[Edge])rMr3rr)rLrrr5)rnrrLrrr)rLzSequence[Sequence[int]]rr)rbrrcrrrrr)rrrr)T)rr|r)rnz list[Vec3]rLz list[Face]r{r&rr|)rnrrr)r9r8r:r8rr8)rCr8rDr8)rZzIterable[Lump]rz list[Lump])rMrrzIterator[MeshTransformer])rhrrirrr)rMrrr)rLrrzdict[Edge, list[Face]])rrrrrr&rrU)rrrrrrU)rrrrrrUr)rrrr&rr)rrrrU)T __future__rtypingrrrrrr r r r r rtyping_extensionsrrrrrrrrrrrrrrrezdxf.entitiesrrrr ezdxf.eztypesr!r"r$r&r3r/r4r5 Exceptionr7r<r?rBrErNrWrZrYrfrrrrrrrUrur|rrrnr rrrrKr]rYrrqrxr{rrrrrrr)r1r2rs#    ( @@/ CLz3-iS/i!D(N+ 9+ y  '  *  +  +     ($ 4800%30 0f$ "$$$.zzzEEP^k^B"I${I$XP$kP$f!!.?@))!+)8;))XQ1 4n@  ' '  .&,3$]G]GF.2 != != +!= !=  !=N.2 =  = + = =F   @)* "% $"r1