OgUddlmZddlmZmZmZmZmZmZm Z m Z m Z m Z m Z ddlmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZe rddlmZm Z m!Z!m"Z"ddl#m$Z$e dZ%Gdd eZ&ee'Z(d e)d <e e'e'fZ*d e)d <ee*e&fZ+d e)d <Gdde,Z-Gdde-Z.Gdde-Z/Gdde-Z0Gdde-Z1dFdZ2dd dGdZ3dHdZ4dIdZ5dJdZ6 dKdZ7 dLd Z8dMd!Z9dNd"Z:Gd#d$Z;Gd%d&Z<Gd'd(e<Z=dOdPd*Z>Gd+d)e<Z?Gd,d-e<Z@Gd.d/ZA dQ dRd0ZBedddZCdSd1ZDdTd2ZEdUd3ZFGd4d5ZGdVd6ZHdVd7ZIdWd8ZJdXd9ZKdYd:ZLdZd;ZMGd<d=ZNd>dd? d[d@ZOd>dA d\dBZP d]dCZQ d^ d_dDZRd`dEZSy>)a) annotations) DictIterableIterator NamedTupleOptionalSequence TYPE_CHECKINGTupleTypeTypeVarUnion) TypeAlias) BoundingBoxMatrix44NULLVECOCSUCSUVecVec3areais_planar_facenormal_vector_3psafe_normal_vectorsubdivide_facesubdivide_ngons)PolyfacePolymeshMeshSolid3d)GenericLayoutTypeTc&eZdZUdZded<ded<y)EdgeStatzNamed tuple of edge statistics.intcountbalanceN)__name__ __module__ __qualname____doc____annotations__V/var/www/html/public_html/myphp/venv/lib/python3.12/site-packages/ezdxf/render/mesh.pyr$r$)s) J Lr.r$rFaceEdge EdgeStatsc eZdZy)MeshBuilderErrorNr(r)r*r-r.r/r4r45r.r4c eZdZy)NodeMergingErrorNr5r-r.r/r8r89r6r.r8c eZdZy)MultipleMeshesErrorNr5r-r.r/r:r:=r6r.r:c eZdZy)DegeneratedPathErrorNr5r-r.r/r<r<Ar6r.r<c eZdZy)NonManifoldMeshErrorNr5r-r.r/r>r>Er6r.r>c#fK|D](}t|dkr|d|dk(r|dd%|*yw)znYields all faces with more than two vertices as open faces (first vertex index != last vertex index). rN)lenfacesfaces r/ open_facesrFIsE t9q=  7d2h s)OJ /1Fclosec#Kt|D]^}|dg}|ddD]}|d|k7s |j|t|dkr<|r|j|dt|`yw)zRemoves duplicated vertices and returns closed or open faces according the `close` argument. Returns only faces with at least 3 edges. rNrAr@)rFappendrBtuple)rDrIrEnew_faceindexs r/normalize_facesrPVs5! G9!"X 'E|u$& ' x=1    OOHQK (Ho s %A0AA0c#VKt|D]}t|Ed{y7w)z$Yields all face edges as int tuples.N)rF face_edgesrCs r/ all_edgesrSjs+5!$d###$#s )')c#fKt|}t|D]}||||dz|zfyw)z5Yields all edges of a single open face as int tuples.rKN)rBrange)rEsizerOs r/rRrRps? t9Dt45k4d 23334rGctdd}i}t|D]@\}}||f}d}||kDr||f}d}|j||\}}t|dz||z||<B|S)a"Returns 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. rrKrA)r$rSget) rDnew_edgestatsabedge orientationr&r's r/get_edge_statsr_ws1~HE% A1!t q5a4DK42wuqy'K*?@d A Lr.ct}|dk(rytj|z }d}d}|D]}t|dkr tfd|D}tj|t|z } t |d|d|d} ||z j} || j| z }|dz }|dkDr||z Sy#t$rYwxYw#t $rYwxYw#t $rYwxYw)aeReturns 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. rr@c3(K|] }| ywNr-.0iverticess r/ z2estimate_face_normals_direction..s!.<sDa199>D)anyrvaluesrs r/is_edge_balance_brokenz#MeshDiagnose.is_edge_balance_broken1s"D4??+A+A+CDDDr.cVtd|jjDS)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:K|]}|jdkyw)r@Nr&rer]s r/rhz+MeshDiagnose.is_manifold..EsGd4::>Grallrrrs r/ is_manifoldzMeshDiagnose.is_manifold>s"Gdoo.D.D.FGGGr.cVtd|jjDS)a<Returns ``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:K|]}|jdk(yw)rjNrrs r/rhz1MeshDiagnose.is_closed_surface..QsHt4::?Hrrrs r/is_closed_surfacezMeshDiagnose.is_closed_surfaceGs"Ht/E/E/GHHHr.cVtd|jjDS)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) c34K|]}|jywrcrrs r/rhz0MeshDiagnose.total_edge_count..Xs=q177=s)rkrrrs r/total_edge_countzMeshDiagnose.total_edge_countSs" =DOO$:$:$<===r.c6|jjS)zBYields the unique edges of the mesh as int 2-tuples. (cached data))rkeysrs r/ unique_edgeszMeshDiagnose.unique_edgesZs##%%r.cBt|j|jS)aReturns 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 for outward pointing faces is assumed but a clockwise (cw) arrangement works too but the return 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. There are no exact confidence values if all faces pointing outwards, here some examples for surfaces created by :mod:`ezdxf.render.forms` functions: - :func:`~ezdxf.render.forms.cube` returns 1.0 - :func:`~ezdxf.render.forms.cylinder` returns 0.9992 - :func:`~ezdxf.render.forms.sphere` returns 0.9994 - :func:`~ezdxf.render.forms.cone` returns 0.9162 - :func:`~ezdxf.render.forms.cylinder` with all hull faces pointing outwards but caps pointing inwards returns 0.7785 but the property :attr:`is_edge_balance_broken` returns ``True`` which indicates the mixed vertex orientation - and the estimation of 0.0469 for a :func:`~ezdxf.render.forms.torus` is barely usable )rwrgrDrs r/rwz,MeshDiagnose.estimate_face_normals_direction^sB/t}}djjIIr.cXtd|jjD S)z+Returns ``True`` if any face is non-planar.c32K|]}t|ywrc)rrerEs r/rhz4MeshDiagnose.has_non_planar_faces..sW~d+W)rrfaces_as_verticesrs r/has_non_planar_facesz!MeshDiagnose.has_non_planar_facess#W 8T8T8VWWWWr.c|jr@d}|jjdD]}|t|d|d|dz }|dz Sy)aKReturns 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!!! rar@rrKrjg@)rr tessellationr)rvolumerEs r/rzMeshDiagnose.volumes\  ! !F //2 ='$q'47DG<< =C< r.c|j}d}|jjD]"}|Dcgc]}|| }}|t|z }$|Scc}w)zReturns the surface area.ra)rgrrFr)rv surface_arearErfrs r/rzMeshDiagnose.surface_areas_ MM JJ))+ -D%)*qt*G* GG, ,L -+s Ac|jdkDr,tj|j|jz StS)z6Returns the centroid of all vertices. (center of mass)r)rprrkrgrrs r/centroidzMeshDiagnose.centroids/ ??Q 88DMM*T__< <r.N)r MeshBuilder)returnSequence[Vec3])rSequence[Face]rr)rr%)rr2rbool)rIterable[Edge])rfloat)rr)r(r)r*rpropertyrgrDrrrprrrrrrrrrrwrrrrr-r.r/rrs#, ##  "" ""$$    == E EHH I I>&!JFX&r.rceZdZdZd&dZd'dZdZd(dZd)dZd*dZ d+dZ d,d Z d-d Z d.d Z d/d Z d0 d1dZ d0 d2dZ d3 d4dZed5dZed6dZ d0 d2dZd7d8dZ d0 d2dZed9dZd:d;dZdd?dZd@dAdZd@dBdZd@dCdZd&dZdDdZ d&dZ!dEdFd Z"d d! dGd"Z# dEd#d d$ dHd%Z$y )IraXA 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 g|_g|_yrcrgrDrs r/rzMeshBuilder.__init__s$& *, r.c,t|jS)z9Returns the :class:`~ezdxf.math.BoundingBox` of the mesh.)rrgrs r/rzMeshBuilder.bboxs4==))r.c$|j|S)zReturns a copy of mesh.) from_builderrs r/copyzMeshBuilder.copys  &&r.ct|S)z7Returns the :class:`MeshDiagnose` object for this mesh.)rrs r/diagnosezMeshBuilder.diagnoses D!!r.c^|jtfd|j|DS)z[Returns the face `index` as sequence of :class:`~ezdxf.math.Vec3` objects. c3(K|] }| ywrcr-)revirgs r/rhz0MeshBuilder.get_face_vertices..s>bXb\>ri)rgrMrD)rrOrgs @r/get_face_verticeszMeshBuilder.get_face_verticess(==>DJJu,=>>>r.cr|j|} t|S#ttf$r tcYSwxYw)zReturns the normal vector of the face `index` as :class:`~ezdxf.math.Vec3`, returns the ``NULLVEC`` instance for degenerated faces. )rr ValueErrorrmr)rrOrEs r/get_face_normalzMeshBuilder.get_face_normals>%%e, %d+ +-. N s 66c#K|jD]} t|y#ttf$r tY-wxYww)z`Yields all face normals, yields the ``NULLVEC`` instance for degenerated faces. N)rrrrmr)rrEs r/rzMeshBuilder.face_normalssK**, D (..  12   s$A 'AAAAAc#zK|j}|jD]}|Dcgc]}|| c}ycc}ww)z%Yields all faces as list of vertices.Nr)rrrErOs r/rzMeshBuilder.faces_as_verticess: MMJJ /D)-.1U8. . /.s ; 6 ;c#JKt|jEd{y7w)zxYields all faces as sequence of integers where the first vertex is not coincident with the last vertex. N)rFrDrs r/rFzMeshBuilder.open_facessdjj)))s #!#cX|jj|j|y)aAdd 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)rDrL add_vertices)rrgs r/add_facezMeshBuilder.add_faces! $++H56r.ct|j}|jjtj|t t |t|jS)adAdd 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 )rBrgextendrgeneraterMrU)rrg start_indexs r/rzMeshBuilder.add_verticessH"$--(  T]]845U;DMM(:;<.+s#HBGBK#Hri) rrrgrDrrrFrLrM)rrgrDrrsrs @r/add_meshzMeshBuilder.add_meshs&  yy/HJJE  AB B ##H-'. JM JJ  e#H-#HH I Jr.cL|r t|ni}|j}||j|}||j|}|j |}|j 5}t ||_t |j|_ddd|S#1swY|SxYw)aRender 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)dictrgtransform_vertices points_to_wcsr edit_datarrD)rlayoutrmatrixucsrgrdatas r/ render_meshzMeshBuilder.render_mesh-s *4T*% ==  00:H ?((2H*5 ^^  *!NDMdjj)DJ  *   *  s $+BB#c<|r t|ni}|jD]k}t|}|dkrtj||z } t |}|r|d|z j|z} n|} |j|||| zz|my#t $rYzwxYw)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}`` r@rrN) rrrBrrkrrm magnitudeadd_line) rrlengthrelativerrEr&centern_lengths r/render_normalszMeshBuilder.render_normalsKs$*4T*% **, QDIEqyXXd^e+F &t,7V+66?  OOFFQ[$8ZO P Q%  s B BBc\|}t|tsJ|j||S)a0Create 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 r/ from_meshzMeshBuilder.from_meshms.u$ ,,, 5 ! r.c x|jdk7rtd|j|}t|tsJ|jr;|j \}}|D]!}|j |j#|S|jr|j}t|jjdz D]^}t|jjdz D]7}|j |||f|||dzf||dz|dzf||dz|ff9`|Std)zxCreate new mesh from a :class:`~ezdxf.entities.Polyface` or :class:`~ezdxf.entities.Polymesh` object. POLYLINEzUnsupported DXF type: rKzNot a polymesh or polyface.)dxftype TypeErrorrris_poly_face_mesh indexed_facesrpointsis_polygon_meshget_mesh_vertex_cacherUdxfm_countn_count) r r r_rDrErgmrs r/ from_polyfacezMeshBuilder.from_polyface}sJ ==?j (4U]]_4EFG Gu$ ,,,  " "**,HAu - dkkm, -   " "224H599,,q01 uyy00145AMM$QTN$QAX.$QUAE\2$QUAX.   9: :r.c|r t|ni}|j|}tj|}||j |||j |j |j |jd||S)aRender 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` rmax_vertex_count)r add_polyfaceMeshTransformerr transformr append_facesr)rrrrrpolyfacets r/render_polyfacezMeshBuilder.render_polyfaces"*4T*% &&*&=  ( ( .   KK  ? KK # NNAN .!  r.cddlm}|r t|ni}|j|}|j |}|j ||g|S)aqRender 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)rrracissolid3dbodys r/render_3dsolidzMeshBuilder.render_3dsolidsM4 +)3T*% $$ $;""4( $(r.c|r t|ni}tj|}||j|||j|j|j dD]}|j ||y)aRender 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` Nrrr)rr!rr"rr add_3dface)rrrrrr%rEs r/render_3dfaceszMeshBuilder.render_3dfacessv"*4T*%  ( ( .   KK  ? KK #NNAN6 ;D   dz  : ;r.c|}t|tsJt|j|_t|j|_|S)zCreate new mesh from other mesh builder, faster than :meth:`from_mesh` but supports only :class:`MeshBuilder` and inherited classes. )rrrrgrDr s r/rzMeshBuilder.from_buildersBu$ ,,,U^^, %++&  r.c|}t|D]"}t|j|j}$tj |S)aReturns 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! )rU_merge_adjacent_coplanar_facesrgrDr!r)rpassesrrs r/merge_coplanar_facesz MeshBuilder.merge_coplanar_facessCv MA1$--LD M++D11r.c|}tt|d}|dkDrt||}|dz}|dkDrtj |S)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 rrK)minr% _subdivider!r)rlevelquadsrs r/ subdividezMeshBuilder.subdividesQCJ"aidE*D QJEai++D11r.cht|}|j|tj|S)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. ) precisionr)MeshVertexMergerrr!r)rrArs r/optimize_verticeszMeshBuilder.optimize_vertices#s-  )4 4  ++D11r.c#TKt|j|Ed{y7w)aYields 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)rrs r/rzMeshBuilder.subdivide_ngons-s"#4#9#9#;=MNNNs (&(c#Kddlm}|jD]%}t||kr|||Ed{'y7w)a%Yields 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.triangulationrFrrB)rrrFrEs r/rzMeshBuilder.tessellation7sH >**, 2D4y,, +D111  22s8AAAct}|j|D]}|j|tj |S)aReturns 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! r)rBrrr!r)rrrrEs r/mesh_tessellationzMeshBuilder.mesh_tessellationEsG !%%7G%H D MM$  ++D11r.cJtt|j|_y)zEFlips the normals of all faces by reversing the vertex order inplace.N)rrzrDrs r/ flip_normalszMeshBuilder.flip_normalsQs+DJJ78 r.c*tt|S)zA single :class:`MeshBuilder` instance can store multiple separated meshes. This function returns this separated meshes as multiple :class:`MeshTransformer` instances. )rseparate_meshesrs r/rMzMeshBuilder.separate_meshesUs OD)**r.cNtt|jd|_y)zRemoves duplicated vertex indices from faces and stores all faces as open faces, where the last vertex is not coincident with the first vertex. FrHN)rrPrDrs r/rPzMeshBuilder.normalize_faces\s /$**EBC r.ct||S)a~Returns 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)rrQs r/face_orientation_detectorz%MeshBuilder.face_orientation_detectorcs'tyAAr.fodct||S)aReturns 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 rT)unify_face_normals_by_majority)rrUs r/unify_face_normalszMeshBuilder.unify_face_normalsos&.d<t|||}|r t|||S)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 )rQrU)unify_face_normals_by_reference%_force_face_normals_pointing_outwards)rrQrYrUrs r/r[z+MeshBuilder.unify_face_normals_by_references%L/tycR  1$ B r.)rNoner)rr)rOr%rr)rOr%rr)rIterator[Vec3])rzIterator[list[Vec3]]rIterator[Face])rgIterable[UVec]rr]rgrarr0)NNN)rgzOptional[list[Vec3]]rDzOptional[list[Face]]rr])rr!rzOptional[Matrix44]rz Optional[UCS])rKTN)rr!rr)r Type[T]r zUnion[MeshBuilder, Mesh]rr")r rcr zUnion[Polymesh, Polyface]rr"rc)rr!rr )r rcr rrr")rK)r7r%rr!)rKT)r=r%rr!)rAr%rr!r)rIterator[Sequence[Vec3]])rr%rrg)rr%rr!)rzlist[MeshTransformer]r)rQr%rrR)rU!Optional[FaceOrientationDetector]rr!)rQr%rUrirr!)%r(r)r*r+rrrrrrrrrFrrrrr classmethodr rr&r0r3rr8r?rCrrrIrKrMrPrSrXr[r-r.r/rrs - *'"?/ * 7=.*.&*  J&J$J  JD%)! !#   B Q! Q QD  B%)! !#   < J%)! ;!;# ;  ;4   2 22O 2 29+D B;?=7= =.)15 )) / )  )r.rcTeZdZdZd dZd d dZdddZddZddZddZ ddZ dd Z y )r!z3A mesh builder with inplace transformation support.cXt|j|j|_|S)zTransform mesh inplace by applying the transformation `matrix`. Args: matrix: 4x4 transformation matrix as :class:`~ezdxf.math.Matrix44` object )rrrg)rrs r/r"zMeshTransformer.transforms$V66t}}EF  r.ct|ttfrt|||}n t|}|jDcgc]}||z c}|_|Scc}w)zTranslate mesh inplace. Args: dx: translation in x-axis or translation vector dy: translation in y-axis dz: translation in z-axis )rrr%rrg)rdxdydzr%rs r/ translatezMeshTransformer.translatesM b5#, 'RR ARA(, 61Q6  7s Ac |jDcgc]\}}}t||z||z||zc}}}|_|Scc}}}w)zScale mesh inplace. Args: sx: scale factor for x-axis sy: scale factor for y-axis sz: scale factor for z-axis )rgr)rsxsyszr}r~r|s r/scalezMeshTransformer.scalesEFJ]]SS'!Qa"fa"fa"f5S  Ts!>cT|jDcgc]}||z c}|_|Scc}w)zfScale mesh uniform inplace. Args: s: scale factor for x-, y- and z-axis )rg)rsrs r/ scale_uniformzMeshTransformer.scale_uniforms()- 61Q6  7s %c~ttj|j|j|_|S)zvRotate mesh around x-axis about `angle` inplace. Args: angle: rotation angle in radians )rrx_rotaterrgrangles r/rotate_xzMeshTransformer.rotate_x/X..u5HHWX  r.c~ttj|j|j|_|S)zvRotate mesh around y-axis about `angle` inplace. Args: angle: rotation angle in radians )rry_rotaterrgr|s r/rotate_yzMeshTransformer.rotate_yrr.c~ttj|j|j|_|S)zvRotate mesh around z-axis about `angle` inplace. Args: angle: rotation angle in radians )rrz_rotaterrgr|s r/rotate_zzMeshTransformer.rotate_zrr.cttj||j|j|_|S)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_rotaterrg)raxisr}s r/ rotate_axiszMeshTransformer.rotate_axiss6  u - @ @ O   r.N)rr)rrr)rnzUnion[float, UVec]rorrpr)rKrKrK)rsrrtrrur)rxr)r}r)rrr}r) r(r)r*r+r"rqrvryr~rrrr-r.r/r!r!s-=   r.r!rBct}|jD]3}t|dkrt||D]}|j |5|S)zReturns a new :class:`MeshVertexMerger` object with subdivided faces and edges. Args: quads: create quad faces if ``True`` else create triangles r@)rBrrBrr)rr>new_meshrgrEs r/r<r<s^ !H**,$ x=1  "8U3 $D   d # $$ Or.cHeZdZdZddfd ZddZd dZed dZxZ S) rBaSubclass 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>t|i|_||_y)z\ Args: precision: floating point precision for vertex rounding NsuperrledgerrArrA __class__s r/rzMeshVertexMerger.__init__6s ') 'r.cg}|j}tj|D]2}|j|} |j |j |4t|S#t $rSt|j}|jj |||j |<|j |YwxYw)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: indices of the added `vertices` ) rArrroundrLrKeyErrorrBrgrM)rrgrrAvertexkeyrOs r/rzMeshVertexMerger.add_vertices@sNN mmH- &F,,y)C &t{{3/0 &W~  &DMM* $$V,#( C u%  &sA$$AC?Cc |jt|j|jS#t$rt dt |dwxYw)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.rrrrArrlstrrrs r/rOzMeshVertexMerger.indexZsS A;;tF|11$..AB B Aws6{m;?@ @ As 03"Ac$|j|Sz(Create new mesh from other mesh builder.r r r s r/rzMeshVertexMerger.from_builderg}}U##r.rdrAr%rbrrrr%)r rrrB r(r)r*r+rrrOrjr __classcell__rs@r/rBrB"s,&(4 A$$r.cHeZdZdZddfd ZddZd dZed dZxZ S) MeshAverageVertexMergerafSubclass 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>t|i|_||_yrcrrs r/rz MeshAverageVertexMerger.__init__s#   (r.cg}|j}tj|D]t}|j|} |j|\}}|j ||z|z}|dz }||z |j |<||f|j|<|j|vt|S#t $rDt|j }|j j||df|j|<YjwxYw)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 rK) rArrrrrgrrBrLrM) rrgrrArrrOr&averages r/rz$MeshAverageVertexMerger.add_verticessNN mmH- "F,,y)C 2#{{3/ u ==/%76A '. e$$)5> C NN5 !! ""W~ .DMM* $$V,$)1: C  .sB&&A C32C3c |jt|j|jdS#t$rt dt |dwxYw)rrrrrrs r/rOzMeshAverageVertexMerger.indexsX A;;tF|11$..AB1E E Aws6{m;?@ @ As 36"Ac$|j|Srrrs r/rz$MeshAverageVertexMerger.from_builderrr.rdrrbr)r rrrrrs@r/rrns-((!F A$$r.rc"eZdZdZddZdddZy)_XFace) fingerprintr _orientationcHt||_||_t|_yrc)hashrr VEC3_SENTINELr)rrs r/rz_XFace.__init__s $W $ "/r.c |jturRt}|jDcgc]}|| c}^}}}|D] } t |||j |}n||_|jScc}w#t $rYFwxYwrc)rrrrrrrm) rrgrAr^rfv0v1rv2s r/r^z_XFace.orientations    -!K/3||"D"DY"OK  !,D    = )s A1A66 BBN)rr0rf)rgrrAr%rr)r(r)r* __slots__rr^r-r.r/rrs:I0 !r.rc i}g}|D]h}t|dkr tdt|}|j||j |j ||gj|jt }t}|D]O}|j|vr|j|j|j}|j ||} || } t|} | D]} | j|vr| jt| j} t| dkDsEt| t| jk(rt|| j}n t|| j}|j| jt|} t!t#|Dcgc]}|| c}}|j%|R|S#ttf$rY wxYwcc}w)Nr@zfound invalid face count < 3rK)rBrrrL setdefaultr^rBsetraddr intersectionmerge_full_patchmerge_connected_pathsr8r<rremove_colinear_face_verticesr)rgrDrAoriented_facesextended_facesrExfacerdoner^parallel_facesface_set parallel_facecommon_verticesrfrs r/r6r6s02N#%N  t9q=;< <t e$!!%"3"3Hi"H"MTT     D 5D    $  ""#}}'')< ' 4t9+ %M((D0&33C 8M8M4NOO?#a''3}/D/D+EE+D-2G2GHD!4T=;P;PQ223t9 %/d0K!0KL M b12 K -.BC! !1Ls$G0 G3G0/G0c#Kd d}t|dkr |Ed{y|dg}|ddD](}|j|dr|j|*t|dkr-t|dk(r|j|d|Ed{y|d}t}t}d}||tur|dz } ||}|||}|turd}|j|||dD]2} ||| j|r| } |d}|}||| }| }4|s|dyy7 7#t$r|YywxYw#t $rYcwxYww) Nc(||z jSrc)rn)rrs r/ get_directionz4remove_colinear_face_vertices..get_directionsR""$$r.r@rrKrAFT)rrrr)rBiscloserLrrlrm) rgr _verticesrstart prev_vertexcurrent_directionryielded_anythingrs r/rrs% 8}q&a[MI ab\ yy2'   Q   9~ y>Q    Yq\ * aLEK%K K } ,q  ";/K*%= } , UKL)  UF+334EF$ G )%8   m ]      !   svE D%'E AE  D( )E 6D*;E  E )D=#E (E * D:7E 9D::E = E E E  E cdd}||}||}|d}|d}|g} ||}||vr||}}||k(rn|}||vrt|j|2t|dkrt|S#t$rtwxYw)Nclt||ddDcic]\}}|| }}}|d||d<|Scc}}w)NrKrrA)zip)pe1e2nodess r/ build_nodesz*merge_connected_paths..build_nodes>sD&)!QqrUm4FBR44tae  5s 0rr@)r Sequence[int])rr8rLrBr<) p1p2r current_path other_path current_nodefinishconnected_path next_nodes r/rr=s r?LRJa5L UF"^N  #$\2I  "'1<*L    > )# "l+   >Q""  #" " #s A++A;ct|}g}t|D]2\}}||dz }||dz|z}||vr||vr"|j|4|S)NrK)rB enumeraterL)pathpatchr&new_pathposnodeprevsuccs r/rr]sj IEHt_ TC!G}S1W%& 5=TU]   Or.c$eZdZddZddZddZy)Lumpct|_|g|_t|D]+\}}|jj ||kr||fn||f-yrc)redgesrDrRr)rrEr[r\s r/rz Lump.__init__jsL # "& t$ 9DAq JJNNQ!VAq6!Q 8 9r.cN|jj|j Src)r isdisjointrr s r/ is_connectedzLump.is_connectedqs::((555r.c|jj|j|jj|jyrc)rDrrupdaters r/mergez Lump.mergets. %++& %++&r.N)rEr0)r rrr)r r)r(r)r*rrrr-r.r/rris96'r.rct|}d}dt|cxkr|k7r2n|St|}t|}dt|cxkr|k7r+|S|S)NrrK) _merge_lumpsrB)lumps merged_lumps prior_lens r/ merge_lumpsrysj&LI c, ,9 ,  % #L1  c, ,9 ,  - r.cg}|D]>}|D]&}|j|s|j|-|j|@|Src)rrrL)rrlumpbases r/rrsZ!L&  &D  & 4  &    % & r.c#tKttdt|jD}t |dkDr`|j |D]N}t }|jD]}|jfd|Dtj|Pytj|yw)zReturns the separated meshes in a single :class:`MeshBuilder` instance as multiple :class:`MeshTransformer` instances. c32K|]}t|ywrc)rrs r/rhz"separate_meshes..s)U$t*)UrrKc3(K|] }| ywrcr-rds r/rhz"separate_meshes..s8ahqk8riN) rrrFrDrBrgrBrr!r)rdisconnected_lumpsrrrErgs @r/rMrMs k)UAGGAT)UUV "::& 5D#%D  9 8488 9!..t4 4  5 **1--sB5B8cLtj|t|z }tj|t|z }t|d|d|ddz}t|d|d|ddz}||z}||z}|j |}|j |} | |kDS)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! rrKrjg?)rrkrBrdistance) f0f1c0c1n0n1e0rd0d1s r/have_away_pointing_normalsrs "B B "B B "Q%A1 . 4B "Q%A1 . 4B bB bB RB RB 7Nr.cddlm}|dj|}|j\}}}}}}t ||S)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. rK)cubeT)formsrr"rr)rr unit_cubebottomrtops r/!face_normals_after_transformationrsCT $$Q'I'99;FAq!Q %fc 22r.czi}|D]3}t|D]#}|j|gj|%5|Src)rRrrL)rDmappingrEr]s r/_make_edge_mappingrsL&(G6t$ 6D   tR ( / / 5 66 Nr.ceZdZdZd ddZeddZeddZeddZeddZ eddZ eddZ d dd Z edd Z dd Zy )rRa 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 c||_t|j|_||_d|_t |_t |_|j|y)NT) rrrD edge_mappingrQrrforwardbackwardclassify_faces)rrrQs r/rz FaceOrientationDetector.__init__sI 4Ftzz4R"(, )-  I&r.c2t|jdk(S)znReturns ``True`` if all reachable faces are forward oriented according to the reference face. r)rBr"rs r/has_uniform_face_normalsz0FaceOrientationDetector.has_uniform_face_normalss 4==!Q&&r.clt|jjt|jk(S)z}Returns ``True`` if all faces are reachable from the reference face same as property :attr:`is_single_mesh`. )rBrrDrkr&rs r/ all_reachablez%FaceOrientationDetector.all_reachables& 4::##$DJJ77r.c|jS)zjReturns ``True`` if only a single mesh is present same as property :attr:`all_reachable`. )r'rs r/is_single_meshz&FaceOrientationDetector.is_single_meshs !!!r.cVt|jt|jfS)z9Returns the count of forward and backward oriented faces.)rBr!r"rs r/r&zFaceOrientationDetector.counts!4<< #dmm"444r.cHt|jjS)z"Yields all forward oriented faces.)iterr!rrs r/ forward_facesz%FaceOrientationDetector.forward_facessDLL'')**r.cHt|jjS)z#Yields all backward oriented faces.)r,r"rrs r/backward_facesz&FaceOrientationDetector.backward_faces sDMM((*++r.c d fd }dfd }d  fd d  fd }t|_d_j t t j j |dfg t r< jd\}}|r ||n|||||t r< _ _ y) zDetect the forward and backward oriented faces. The forward and backward orientation has to be defined by a `reference` face. c"|t|<yrcid)fr!s r/ add_forwardz;FaceOrientationDetector.classify_faces..add_forwardsGBqENr.c"|t|<yrcr2)r4r"s r/ add_backwardz.add_backwardsHRUOr.cVt|}|vr|vrj||fyyyrc)r3rL)r4r^rr"r! process_facess r/add_face_to_processzCFaceOrientationDetector.classify_faces..add_face_to_processs6Q%C'!c&9$$a%56':!r.ct|D][}|}t|dkDr|D]}||ur||  |d|df}t|dk(r |d|Ud_]y#t$rYjwxYw)NrKrF)rRrBrr)r4r^r] linked_faces linked_facer:r rs r/#add_adjacent_faces_to_process_queuezSFaceOrientationDetector.classify_faces..add_adjacent_faces_to_process_queue#s"1  -+D1 |$q('3J &!+$+K[IJ #/Qa0@#AL|$)' QE(-D$) - s A,, A87A8TrN)r4r0)r4r0r^r) r%rQrr rrrDrBpopr!r") rrQr5r7r>rEface_orientationr:r"r r!r9s ` @@@@@r/r#z&FaceOrientationDetector.classify_facess   7  -.Y(( #'6$(F37::3C3CI3NPT2U1V - %2%6%6q%9 "D"D!T" /6F G-    r.c|jsyg}|j}|jD]L}|j||}|d|df}|j||}t |t |zdk7sLyy)a.Returns ``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. FrKrrjT)rr rrXrB)remptyr r]forward_connected_faces reversed_edgebackward_connected_facess r/rz)FaceOrientationDetector.is_closed_surfaceMs((  %%' D&2&6&6tU&C # GT!W,M'3'7'7 u'M $*+c2J.KKqP   r.cddlm}t|jj }||j }|||S)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.mathrHrrrrQ)rrHrDreference_faces r/#is_reference_face_pointing_outwardsz;FaceOrientationDetector.is_reference_face_pointing_outwardsds: @TZZ1134t~~./~FFr.Nrh)rrrQr%r)rztuple[int, int]r_)rQr%rr])r(r)r*r+rrr%r'r)r&r-r/r#rrKr-r.r/rRrRs$''' 88 "" 55++,,:!x, Gr.rRN)rUrQc@| t||}dd}t|||S)aUnifies 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 c|jSrc)r")detectors r/backward_selectorz:unify_face_normals_by_reference..backward_selectors   r.rNrRrR_unify_face_normals)rrUrQrOs r/r[r[qs,6 {%dI6! tS*; <| t|}dd}t|||S)aUnifies the orientation of all faces of a :class:`MeshBuilder` object. The forward orientation is defined by the orientation 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. 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. Raises: NonManifoldError: non-manifold mesh MultipleMeshesError: :class:`MeshBuilder` object contains multiple disconnected meshes cZ|j\}}||k\r |jS|jSrc)r&r"r!)rNcount0count1s r/rOz9unify_face_normals_by_majority..backward_selectors-!$*f$4x  J(:J:JJr.rPrQ)rrUrOs r/rWrWs+2 {%d+K tS*; <r'r:rQr!rrgr%rDr3rLrMry)rrUrOrr"rDrEs r/rRrRs ??"#677   !?  O   HT]]+H  ' '$S)JJ *D$x8# U8D>23 U4[)  *  Odjj) Or.cddlm}t|j}||}|||s|j yy)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 rrGN)rIrHrrrK)rrQrHrDrJs r/r\r\s@< '') *E9%N +E> B  Cr.c|j}|j|jd}|js t d|j s)t t|d}|jd}|jst||}|j}|jr |js|j|S)aReturns 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 rrPrXrT) rCrPrSrr>r'rrMr%r[rrKrK)rrrUs r/normalize_meshr[s"%%'H   , ,q , 9C ??"#677   12150010=  ' '28E002 S%L%L%N Or.)rDIterable[Face]rr`)rDzlist[Sequence[int]]rIterator[Sequence[int]])rDr\rzIterator[Edge])rEr0rr)rDr\rr2)rgrrDrrr)rDzSequence[Sequence[int]]rr])r[rr\rrrrr)rrrr)T)rrBrf)rgz list[Vec3]rDz list[Face]rAr%rrB)rgrrr^)rrrrrr)rrrr)rzIterable[Lump]rz list[Lump])rrrzIterator[MeshTransformer])r rr rrr)rrrr)rDr\rzdict[Edge, list[Face]])rrrUrirQr%rr!)rrrUrirr!)rrrUrRrr!rh)rrrQr%rr])rrrr!)T __future__rtypingrrrrrr r r r r rtyping_extensionsrrIrrrrrrrrrrrrrezdxf.entitiesrrrr ezdxf.eztypesr!r"r$r%r0r,r1r2 Exceptionr4r8r:r<r>rFrPrSrRr_rwrzrrrrr!r<rBrrr6rrrrrrrrMrrrrRr[rWrRr\r[r-r.r/rds#    ( @@/ 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   @)* "% $"r.