Mi SrSSKJr SSKrSSKJrJrJr SSKJ r J r J r J r J r JrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJrJr SSK J!r!J"r"J#r#J$r$ SSK%J&r&J'r' SS K(J)r) SS K*J+r+ SS K,J-r- SS K.J/r/ SS KJ0r0 SSK1J2r2J3r3J4r4J5r5J6r6J7r7J8r8J9r9J:r:J;r;Jr>J?r?J@r@JArA SSKJBrBJCrCJDrD SSKEJFrF SSKGJHrH SSKKJLrL SSKMJNrN SSKOJPrP SSKQJRrRJSrS \R"S\R S9rUS\URlW\R"S\R S9rXS\XRlW"SS\-5rYg!\IarJ\)"\J5rH\)"\J5rFSrJCJNSrJCJff=f!\IarJ\)"\J5rLSrJCJNSrJCJff=f!\IarJ\)"\J5rNSrJCJNSrJCJff=f!\IarJ\)"\J5rPSrJCJNSrJCJff=f!\IarJ\)"\J5rR\)"\J5rSSrJCJNSrJCJff=f)z # trimesh https://github.com/mikedh/trimesh --------------------------------- Library for importing, exporting and doing simple operations on triangular meshes. )deepcopyN)float64int64ndarray)boolean comparisonconvex curvature decompositiongeometrygraphgroupinginertia intersections permutateposes proximityray registrationremeshrepairsampletransformations trianglesunitsutilvisual)Cache DataStore TrackedArraycache_decorator)logtol)ExceptionWrapper export_mesh) Geometry3DScene)MassProperties)Any ArrayLikeBooleanEngineTypeDictFloatingIntegerListLoadableNDArrayNumberOptionalSelfSequenceTupleUnion ViewerType) ColorVisualsTextureVisuals create_visual) coo_matrix)cKDTree)Graph)Image)Index)Path2DPath3DdtypeFc$,\rSrSrSS\\S\\S\\S\\S\\S\\S \\\\4S \\\\4S \\\\4S \ S \ S\\ S\\ S\ S\\\\ 4S\\ \ \ 4SS4"SjjrSS \ S\\ S\\ S\4Sjjr\S\ 4Sj5r\R&S\ SS4Sj5r\S\4Sj5r\R&S\\SS4Sj5r\S\4Sj5r\S\\4Sj5r\R&S\\SS4Sj5r\S\4Sj5r\R&S\\SS4S j5r\S\\4S!j5r\R&S\SS4S"j5r\S\\4S#j5r\S\\\4S$j5r \S\\\4S%j5r!\S\\4S&j5r"\S\\4S'j5r#\#R&S\SS4S(j5r#\S\$4S)j5r%\%R&S\&SS4S*j5r%\S\4S+j5r'\S\4S,j5r(\S\\4S-j5r)S.\S\\4S/jr*\S\\4S0j5r+\S\\4S1j5r,\S\\4S2j5r-\S\\4S3j5r.\S\\\4S4j5r/\S\\\4S5j5r0\S\\4S6j5r1\S\24S7j5r3\S\\4S8j5r4\S\\4S9j5r5\S\\4S:j5r6\S\\4S;j5r7\S\\4S<j5r8\S\\4S=j5r9\S\\4S>j5r:\S\\4S?j5r;\S\<4S@j5r=\S\4SAj5r>\S\?4SBj5r@\S\\4SCj5rA\S\?4SDj5rB\S\\CR4SEj5rESSF\SG\ S\4SHjjrFSS\\ S\\ SI\\GSJ\\GSK\\GSS4 SLjjrHSSM\SN\\SS4SOjjrISM\SS4SPjrJSQ\4SRjrKSSSjrLS\\CR4STjrMSSUjrNS\OS4SVjrP\S\\4SWj5rQ\S\\4SXj5rR\S\\4SYj5rS\S\<4SZj5rT\S\\4S[j5rU\S\\4S\j5rV\S\\CR4S]j5rW\S\\4S^j5rX\S\\4S_j5rY\S\\4S`j5rZ\S\4Saj5r[\S\\4Sbj5r]\S\O\O\4Scj5r^\S\ 4Sdj5r_\S\ 4Sej5r`\S\ 4Sfj5ra\S\ 4Sgj5rb\S\ 4Shj5rc\S\<4Sij5rd\eR4Sj\gS\\CR4Skjjrh\S\O\\4Slj5ri\S\\4Smj5rj\S\\4Snj5rk\S\\4Soj5rl\S\O\\4Spj5rm\S\\CR4Sqj5rnSSr\\ S\4SsjjroS\ 4StjrpSu\ \q\4S\r\\\44SvjrsSSw\\\Sx\gSy\GSz\gS\r\\\\44 S{jjrtSS|\\S}\\GSS4S~jjruSS\&S\GS\ S\ S\rS\\444SjjrvSS}\\GSS4Sjjrw\SSj5rx\S\\ \ \ 44Sj5ry\yR&S\\ \ \ 4SS4Sj5ryS\S\S\\z4Sjr{S\S\S\S\O\\|4Sjr}SS\S\S\ S|\\SS4 Sjjr~SS\SS4Sjjr\SSj5rSS\GS\ S\\\4SjjrSSjrSSjrS\S\4SjrSS\\gS\4SjjrSS\\gS\\GS\\GSS4SjjrSS\\\S\z4SjjrS\S\|4Sjr\S\4Sj5r\S\\4Sj5r\S\4Sj5rS\4SjrS\4SjrSS\S\4SjjrSS\\S\ S\ S\ S\OS44Sjjr\S\\4Sj5r\S\4Sj5rSS\S\\S\ \\\44SjjrS\\\ \\O\O\$\O\O\?444SjrS\OS4SjrSSu\ S\S4S\S\ SS4SjjrSSu\ S\S4S\S\ SS4SjjrSSu\ S\S4S\S\ SS4SjjrS\S\\CR4Sjr\S\\4Sj5r\S\4Sj5r\S\\4Sj5r\S\\4Sj5r\S\24Sj5rSS\ S\ SS4SjjrSSjrSSjrS\S\4SjrSSjrSrg)TrimesheNverticesfaces face_normalsvertex_normals face_colors vertex_colorsface_attributesvertex_attributesmetadataprocessvalidate merge_tex merge_norm use_embree initial_cacherreturnc [5Ul[URRSS9UlUbURR U5 XlX l0Ul0Ul Uc[XVUS9Ul O)UUl UbX`RS'UbXPRS'UbX0l UbX@l [R(a,U(a%[R R#U5UlO$[R$R#U5Ul[&R("U5Ul[*R,"U5Ul0Ul[3U [45(aUR0R U 5 OU b[7SU <35eUbURR U5 UbURR U5 U (dU (aUR9XU S9 gg)a A Trimesh object contains a triangular 3D mesh. Parameters ------------ vertices : (n, 3) float Array of vertex locations faces : (m, 3) or (m, 4) int Array of triangular or quad faces (triangulated on load) face_normals : (m, 3) float Array of normal vectors corresponding to faces vertex_normals : (n, 3) float Array of normal vectors for vertices face_colors : (n, 3|4) uint8 Array of colors for faces vertex_colors : (n, 3|4) uint8 Array of colors for vertices face_attributes : dict Attributes corresponding to faces vertex_attributes : dict Attributes corresponding to vertices metadata : dict Any metadata about the mesh process : bool if True, Nan and Inf values will be removed immediately and vertices will be merged validate : bool If True, degenerate and duplicate faces will be removed immediately, and some functions will alter the mesh to ensure consistent results. merge_tex : bool If True textured meshes with UV coordinates will have vertices merged regardless of UV coordinates merge_norm : bool If True, meshes with vertex normals will have vertices merged ignoring different normals use_embree : bool If True try to use pyembree raytracer. If pyembree is not available it will automatically fall back to a much slower rtree/numpy implementation initial_cache : dict A way to pass things to the cache in case expensive things were calculated before creating the mesh object. visual : ColorVisuals or TextureVisuals Assigned to self.visual T) id_functionforce_immutableN)rQrRmeshcolorz'metadata should be a dict or None, got )rWrXrY)r _datar__hash___cacheupdaterMrNrSrTr>rrOrPr has_embree ray_pyembreeRayMeshIntersector ray_triangler PermutatorrProximityQuerynearestrU isinstancedict ValueErrorrV)selfrMrNrOrPrQrRrSrTrUrVrWrXrYrZr[rkwargss f/var/www/eduai.edurigo.com/storigo/production/storigo_env/lib/python3.13/site-packages/trimesh/base.py__init__Trimesh.__init__fsT[  (;(;TR  $ KK  } - !   "!# >''4DK!DK(2?&&w/&0;$$W-  # ,   %"0  >>j''::4@DH ''::4@DH#--d3!//5  h % % MM  *  !FxlST T  &  ' ' 8  (  " " ) )*; < h LL(JL WcUR(aU$U(aBUR5UR5-nURU5 UR 5 UR  UR 5 URX#S9 UR RSS1S9 SSS5 SURS'U$!,(df  N=f)a Do processing to make a mesh useful. Does this by: 1) removing NaN and Inf values 2) merging duplicate vertices If validate: 3) Remove triangles which have one edge of their 2D oriented bounding box shorter than tol.merge 4) remove duplicated triangles 5) Attempt to ensure triangles are consistently wound and normals face outwards. Parameters ------------ validate : bool Remove degenerate and duplicate faces. merge_tex : bool If True textured meshes with UV coordinates will have vertices merged regardless of UV coordinates merge_norm : bool If True, meshes with vertex normals will have vertices merged ignoring different normals Returns ------------ self: trimesh.Trimesh Current mesh )rXrYrOrPexcludeNT processed) is_empty unique_facesnondegenerate_faces update_faces fix_normalsrdremove_infinite_valuesmerge_verticesclearrU)rprWrXrYmasks rrrVTrimesh.processsJ ==K $$&)A)A)CCD   d #    [[  ' ' )   )  K KK  ~7G&H  I &* k" [s );B== C c.URR$)z Is the current mesh allowed to be altered in-place? Returns ------------- mutable If data is allowed to be set for the mesh. rbmutablerps rrrTrimesh.mutable?szz!!!ruvaluec$XRlg)z Set the mutability of the current mesh. Parameters ---------- value Change whether the current mesh is allowed to be altered in-place. Nrrprs rrrrKs# ruc URS$)a5 The faces of the mesh. This is regarded as core information which cannot be regenerated from cache and as such is stored in `self._data` which tracks the array for changes and clears cached values of the mesh altered. Returns ---------- faces : (n, 3) int64 References for `self.vertices` for triangles. rNrbrs rrrN Trimesh.facesWszz'""ruvaluesc<Uc[R"S[S9nO[R"U[S9n[ UR 5S:Xa?UR SS:wa,[ R"S5 [R"U5nXRS 'g) z Set the vertex indexes that make up triangular faces. Parameters -------------- values : (n, 3) int64 Indexes of self.vertices NrrFshaperHrGrrFztriangulating facesrN) npzerosr asanyarraylenrr#infor triangulate_quadsrbrprs rrrNrhst >XXF%8F]]67F v||  !fll1o&: HH* +//7F$ 7rucf[R"[UR5URS9$)z A sparse matrix representation of the faces. Returns ---------- sparse : scipy.sparse.coo_matrix Has properties: dtype : bool shape : (len(self.vertices), len(self.faces)) )columnsindices)r index_sparserrMrNrs rr faces_sparseTrimesh.faces_sparses$$$S-?TTrucpURSnSUR;aURRSnOSnUb[U5S:Xa([R "/[ S9RS5$[R"U5[R"U5:XaU$[R"URURS9up4UR5(aX0RS'U$[R"[UR5S4[ S9nX5U'XPRS'U$) z Return the unit normal vector for each face. If a face is degenerate and a normal can't be generated a zero magnitude unit vector will be returned for that face. Returns ----------- normals : (len(self.faces), 3) float64 Normal vectors of each face rOrNNrrGr)rcrossesrF)rdrbdatarrarrayrreshaperrnormalstriangles_crossallr)rpcachedrNrvalidpaddeds rrrOTrimesh.face_normalss^, djj JJOOG,EE =CJ!O88Bg.66v> > 88F rxx .M #**nnd.B.B  99;;*1KK 'N3t~~.2'Bu '- N# ruc(Ucg[R"US[S9n[U5S:Xd$URUR R:wa[ R"S5 g[R"U5n[R"U5(d[ R"S5 gU[R:a[ R"S5 g[R"URR[R 5UR SS5up4[R""[U5S 45nX5U'[R$"XQSS5(d[ R"S 5 gXR&S 'g) z Assign values to face normals. Parameters ------------- values : (len(self.faces), 3) float Unit face normals. If None will clear existing normals. NCorderrHrz'face_normals incorrect shape, ignoring!z#face_normals contain NaN, ignoring!z face_normals all zero, ignoring!rFz.face_normals didn't match triangles, ignoring!rO)rrrrrrNr#debugptpisfiniter$mergerrrMviewrrallcloserd)rprrcheckrcompares rrrOrs  > vS@ v;! v||tzz/?/?? II? @ ffVn{{3 II; <  ? II8 9 !((););BJJ)G SVTV)XY ((CJ?+{{73BK00 IIF G '- N#ruc URS$)aG The vertices of the mesh. This is regarded as core information which cannot be generated from cache and as such is stored in self._data which tracks the array for changes and clears cached values of the mesh if this is altered. Returns ---------- vertices : (n, 3) float Points in cartesian space referenced by self.faces rMrrs rrrMTrimesh.verticess zz*%%rucUc[R"S[S9n[R"US[S9URS'g)zf Assign vertex values to the mesh. Parameters -------------- values : (n, 3) float Points in space NrrrrrM)rrrrrbrs rrrMrs4 >XXF':F!#vS!P :ruc[R"[UR5URUR UR S9$)a The vertex normals of the mesh. If the normals were loaded we check to make sure we have the same number of vertex normals and vertices before returning them. If there are no vertex normals defined or a shape mismatch we calculate the vertex normals from the mean normals of the faces the vertex is used in. Returns ---------- vertex_normals : (n, 3) float Represents the surface normal at each vertex. Where n == len(self.vertices) ) vertex_countrNrO face_angles)r weighted_vertex_normalsrrMrNrOrrs rrrPTrimesh.vertex_normals s<"//T]]+****((   ruc"Ub[R"US[S9nURURR:XaM[R "U5[ R:a[R"S5 XRS'ggg)z Assign values to vertex normals. Parameters ------------- values : (len(self.vertices), 3) float Unit normal vectors for each vertex Nrrzvertex_normals are all zero!rP) rrrrrMrr$rr#rrdrs rrrPr"sj  ]]6GDF||t}}22266&>CII-II<=06 ,- 3 ruc[R"[UR5URUR S9nU$)aZ A representation of the face indices that correspond to each vertex. Returns ---------- vertex_faces : (n,m) int Each row contains the face indices that correspond to the given vertex, padded with -1 up to the max number of faces corresponding to any one vertex Where n == len(self.vertices), m == max number of faces for a single vertex )rrNr)r vertex_face_indicesrrMrNr)rp vertex_facess rrrTrimesh.vertex_faces4s8 33T]]+**** rucURURn[U5S:Xag[R"UR SS9UR SS9/5$)z The axis aligned bounds of the faces of the mesh. Returns ----------- bounds : (2, 3) float or None Bounding box with [min, max] coordinates If mesh is empty will return None rNaxis)rMreferenced_verticesrrrminmax)rpin_meshs rrboundsTrimesh.boundsGsQ-- 8 89 w<1 xx!,gkkqk.ABCCruc`URcg[R"URSS9nU$)z The length, width, and height of the axis aligned bounding box of the mesh. Returns ----------- extents : (3, ) float or None Array containing axis aligned [length, width, height] If mesh is empty returns None Nrr)rrr)rpextentss rrrTrimesh.extentsZs* ;; &&1-ruc[R"URURSS9nU$![a URR SS9nU$f=f)a  The point in space which is the average of the triangle centroids weighted by the area of each triangle. This will be valid even for non-watertight meshes, unlike self.center_mass Returns ---------- centroid : (3, ) float The average vertex weighted by face area r)weightsrr)raveragetriangles_center area_faces BaseExceptionmean)rpcentroids rrrTrimesh.centroidmsZ" :zz$"7"7WXYH :,,11q19H :s*.#AAc.URR$)z The point in space which is the center of mass/volume. Returns ----------- center_mass : (3, ) float Volumetric center of mass of the mesh. )mass_properties center_massrs rrrTrimesh.center_masss##///ruc[R"U[S9nURS:wa [ S5eXR S'UR RS5 g)z Override the point in space which is the center of mass and volume. Parameters ----------- center_mass : (3, ) float Volumetric center of mass of the mesh. rG)rFzshape must be (3,) float!rrN)rrrrrorbrddeleters rrrrsKg. ;;$ 89 9$) =! ,-ruc@[URR5$)zt The density of the mesh used in inertia calculations. Returns ----------- density The density of the primitive. )floatrdensityrs rrrTrimesh.densitysT))1122rucj[U5URS'URRS5 g)z Set the density of the primitive. Parameters ------------- density Specify the density of the primitive to be used in inertia calculations. rrN)rrbrdrrs rrrrs)!&e  9 ,-ruc.URR$)z Volume of the current mesh calculated using a surface integral. If the current mesh isn't watertight this is garbage. Returns --------- volume : float Volume of the current mesh )rvolumers rrrTrimesh.volumes##***ruc.URR$)z Mass of the current mesh, based on specified density and volume. If the current mesh isn't watertight this is garbage. Returns --------- mass : float Mass of the current mesh )rmassrs rrr Trimesh.masss##(((ruc.URR$)a Return the moment of inertia matrix of the current mesh. If mesh isn't watertight this is garbage. The returned moment of inertia is *axis aligned* at the mesh's center of mass `mesh.center_mass`. If you want the moment at any other frame including the origin call: `mesh.moment_inertia_frame` Returns --------- inertia : (3, 3) float Moment of inertia of the current mesh at the center of mass and aligned with the cartesian axis. )rrrs rrmoment_inertiaTrimesh.moment_inertias ##+++ru transformcURn[R"S5nUS*USS2S4'[R"US[R "X15USSS9$) a Get the moment of inertia of this mesh with respect to an arbitrary frame, versus with respect to the center of mass as returned by `mesh.moment_inertia`. For example if `transform` is an identity matrix `np.eye(4)` this will give the moment at the origin. Uses the parallel axis theorum to move the center mass tensor to this arbitrary frame. Parameters ------------ transform : (4, 4) float Homogeneous transformation matrix. Returns ------------- inertia : (3, 3) Moment of inertia in the requested frame. rIrNrFrrT)inertia_tensorrr parallel_axis)rreyertransform_inertiadot)rprpropsoffsets rrmoment_inertia_frameTrimesh.moment_inertia_framesj.$$}--rr1u (( +ffV/v   rucf[R"UR5upX RS'U$)z Return the principal components of inertia Ordering corresponds to mesh.principal_inertia_vectors Returns ---------- components : (3, ) float Principal components of inertia principal_inertia_vectors)rprincipal_axisrrd)rp componentsvectorss rrprincipal_inertia_components$Trimesh.principal_inertia_componentss0&44T5H5HI 3: /0ruc8URnURS$)z Return the principal axis of inertia as unit vectors. The order corresponds to `mesh.principal_inertia_components`. Returns ---------- vectors : (3, 3) float Three vectors pointing along the principal axis of inertia directions r)rrdrp_s rrr!Trimesh.principal_inertia_vectors!s  - -{{677rucz[R"UR5SSSSS2nURUn[R"U[R "U645n[R "S5nX#SS2SS24'[R"X0RS9nUSS2S4==UR-ss'U$)z A transform which moves the current mesh so the principal inertia vectors are on the X,Y, and Z axis, and the centroid is at the origin. Returns ---------- transform : (4, 4) float Homogeneous transformation matrix rNrIrF)matrixpoint) rargsortrrvstackcrossrrtransform_aroundr)rprrrs rrprincipal_inertia_transform#Trimesh.principal_inertia_transform0s 4<<=abA$B$G007))Wbhh&89:FF1I #"1"bqb&#44MM  "1"a%DMM)rucp[R"U5upnX RS'X0RS'U$)z Check whether a mesh has rotational symmetry around an axis (radial) or point (spherical). Returns ----------- symmetry : None, 'radial', 'spherical' What kind of symmetry does the mesh have. symmetry_axissymmetry_section)rradial_symmetryrd)rpsymmetryrsections rrrTrimesh.symmetryIs7#*"9"9$"?'+ O$*1 &'ruc<URcgURS$)z If a mesh has rotational symmetry, return the axis. Returns ------------ axis : (3, ) float Axis around which a 2D profile was revolved to create this mesh. Nrrrdrs rrrTrimesh.symmetry_axisYs  == {{?++ruc<URcgURS$)z If a mesh has rotational symmetry return the two vectors which make up a section coordinate frame. Returns ---------- section : (2, 3) float Vectors to take a section along Nrrrs rrrTrimesh.symmetry_sectiongs! == {{-..rucnURR[R5UR$)z Actual triangles of the mesh (points, not indexes) Returns --------- triangles : (n, 3, 3) float Points of triangle vertices )rMrrrrNrs rrrTrimesh.trianglesvs&}}!!"**-djj99rucB[R"UR5$)z An R-tree containing each face of the mesh. Returns ---------- tree : rtree.index Each triangle in self.faces has a rectangular cell )r bounds_treers rrtriangles_treeTrimesh.triangles_trees$$T^^44ruc4URRSS9$)z The center of each triangle (barycentric [1/3, 1/3, 1/3]) Returns --------- triangles_center : (len(self.faces), 3) float Center of each triangular face rr)rrrs rrrTrimesh.triangles_centers~~"""**rucF[R"UR5nU$)z} The cross product of two edges of each triangle. Returns --------- crosses : (n, 3) float Cross product of each triangle )rr )rprs rrrTrimesh.triangles_crosss//$..1ruc[R"URR[R 5SS9upX R S'U$)zx Edges of the mesh (derived from faces). Returns --------- edges : (n, 2) int List of vertex indices making up edges T) return_index edges_face)r faces_to_edgesrNrrrrd)rpedgesindexs rrr+ Trimesh.edgess? .. JJOOBJJ 'd %* L! ruc8URnURS$)zf Which face does each edge belong to. Returns --------- edges_face : (n, ) int Index of self.faces r))r+rdrs rrr)Trimesh.edges_faces JJ{{<((ruc[R"UR5upURUnXRS'X RS'U$)zo The unique edges of the mesh. Returns ---------- edges_unique : (n, 2) int Vertex indices for unique edges edges_unique_idxedges_unique_inverse)r unique_rows edges_sortedrd)rpuniqueinverse edges_uniques rrr7Trimesh.edges_uniquesN#..t/@/@A((0 +1 &'.5 *+ruc[R"URURR6n[ R "U5nU$)zz How long is each unique edge. Returns ---------- length : (len(self.edges_unique), ) float Length of each unique edge )rsubtractrMr7Trrow_norm)rpvectorlengths rredges_unique_lengthTrimesh.edges_unique_lengths:dmmD,=,=,?,?@Av& ruc8URnURS$)a Return the inverse required to reproduce self.edges_sorted from self.edges_unique. Useful for referencing edge properties: mesh.edges_unique[mesh.edges_unique_inverse] == m.edges_sorted Returns ---------- inverse : (len(self.edges), ) int Indexes of self.edges_unique r2)r7rdrs rrr2Trimesh.edges_unique_inverses   {{122rucD[R"URSS9nU$)zr Edges sorted along axis 1 Returns ---------- edges_sorted : (n, 2) Same as self.edges but sorted along axis 1 rr)rsortr+)rpr4s rrr4Trimesh.edges_sortedswwtzz2 ruc,[UR5$)z A KDTree for mapping edges back to edge index. Returns ------------ tree : scipy.spatial.cKDTree Tree when queried with edges will return their index in mesh.edges_sorted )r@r4rs rredges_sorted_treeTrimesh.edges_sorted_treest(())rucj[R"UR[UR5S9nU$)z Edges in sparse bool COO graph format where connected vertices are True. Returns ---------- sparse: (len(self.vertices), len(self.vertices)) bool Sparse graph in COO format )count)r edges_to_coor+rrM)rpsparses rr edges_sparseTrimesh.edges_sparses(##DJJc$--6HI rucx[RRURSSS9upX RS'U$)z How many connected groups of vertices exist in this mesh. Note that this number may differ from result in mesh.split, which is calculated from FACE rather than vertex adjacency. Returns ----------- count : int Number of connected vertex groups FT)directed return_labelsvertices_component_label)rcsgraphconnected_componentsrMrd)rprJlabelss rr body_countTrimesh.body_count s@ ::   T; 39 ./ rucZURnURSRS5nU$)a For each face return which indexes in mesh.unique_edges constructs that face. Returns --------- faces_unique_edges : (len(self.faces), 3) int Indexes of self.edges_unique that construct self.faces Examples --------- In [0]: mesh.faces[:2] Out[0]: TrackedArray([[ 1, 6946, 24224], [ 6946, 1727, 24225]]) In [1]: mesh.edges_unique[mesh.faces_unique_edges[:2]] Out[1]: array([[[ 1, 6946], [ 6946, 24224], [ 1, 24224]], [[ 1727, 6946], [ 1727, 24225], [ 6946, 24225]]]) r2rrF)r7rdr)rprresults rrfaces_unique_edgesTrimesh.faces_unique_edges3s.:   34<URRS:Xa"[R"[ U55X!'OSnUbW[R"URS5(a1X RR!S5R!S5UlUR"R%U5 UR&S n[ UR5nUR(R+5H1upV[ U5U:wa [-5eXaUR(U'M3 URUUl[R"US5(a X1Ulgg![,a M~f=f![0a gf=f) z Update vertices with a mask. Parameters ------------ mask : (len(self.vertices)) bool Array of which vertices to keep inverse : (len(self.vertices)) int Array to reconstruct vertex references such as output by np.unique NrcrrGbirYrrP)rzrrrHnamerrrrMrkindaranger_ris_shaperNrrupdate_verticesrdrTitems TypeErrorrPr)rprr6cached_normalsrJkeyrs rrrxTrimesh.update_verticess" == }}T" JJOOv %$((**Ta4==  ?hhs4==1?Gzz#% " $((* 5 C' " #d) 4   4==W#E#E !3!3B!78@@IDJ ##D)%56DMM"00668JC u:&#+%' +0+D " "3 '9 d+  == 1 1 &4&:# 2  !  s$ I  I II I)(I)cUR(ag[R"U5nURRS:XaUR 5(agUR SnURSn[R"US5(dUR Sn[UR5nURR5H1upV[U5U:wa [5eXaURU'M3 X1Ul URR!U5 [R"US5(a X!Ulgg![a Mf=f)a: In many cases, we will want to remove specific faces. However, there is additional bookkeeping to do this cleanly. This function updates the set of faces with a validity mask, as well as keeping track of normals and colors. Parameters ------------ mask : (m) int or (len(self.faces)) bool Mask to remove faces NrcrOrNrY)rzrrrHrtrrdrbrrwrrNrSryrzrr}rO)rprr{rNrJr|rs rrr}Trimesh.update_facess* == }}T" ::??f $ ^4 7#}}UG,,KK(EDJJ..446JC u:&#+%' ). D  %7[    & == 1 1 . 4D  2  sE EE new_facesc "[R"U[RS9n[UR5S:wdURSS:wa[ SURS35e[U5S:XagUR R5 S up#[R"URU5upEXn[U5S:XagS UR R;a?UR RS n[U5S:a[R"Xd45nURR(atURR S :XaZ[R"URR"[R$"[R&[U5S4545n[UR(S 5n[R"UR(S U45UlUR R5 UbX R S 'UbX0Rl0nUR,R/5Hup[R"U 5n [U 5S:Xd U SU:waM5U R0R S :XaSOSn [U54U SS-n [R2"XU R0S9n[R4"X45X'M UR,R7U5 g)a; Extend `mesh.faces` in-place with new triangles. This does substantial bookkeeping: padding face colors and face attributes with default values, and preserving cached face normals to avoid recomputing every normal. Parameters ------------ new_faces : (n, 3) integer The new faces as indexes of `self.vertices` rGrrrFzFaces must be triangular, not `z`!rNNNrOfacerNrsr)rrrrrrordverifyrrrMcacher vstack_emptyrdefinedrurQtile DEFAULT_COLORrbrNrSryrHfull concatenatere)rprextend_normals extend_colors new_normalsrr{original_length new_attribsrtattribrfill pad_shapepads rr extend_facesTrimesh.extend_faces#stMM)288< y 1 $ (:a(?>y>OrRS S y>Q   )3%'..t}}Y/GH $ y>Q   T[[.. .![[..~>N>"Q&!%!2!2N3P!Q ;;  4;;#3#3v#= --KK++GGF003y>12EFMdjj12&& 7(;Y'GH    %*8KK '  $&3KK #  00668LDHHV$E5zQ%(o"=**c12qDY)E!"I5I'')>C "} =K 9 ##K0ruc[R"URS5(a>[R"UR5R SS9nUR U5 [R"URS5(a?[R"UR5R SS9nURU5 gg)z Ensure that every vertex and face consists of finite numbers. This will remove vertices or faces containing np.nan and np.inf Alters `self.faces` and `self.vertices` rYrrN) rrwrNrrrr}rMrx)rp face_mask vertex_masks rrrTrimesh.remove_infinite_valuesls ==W - - DJJ/333;I   i ( == 0 0++dmm488a8@K   - 1ruc [R"[UR5[S9nSU[ R "[R"URSS95S'U$)z On the current mesh find which faces are unique. Returns -------- unique : (len(faces),) bool A mask where the first occurrence of a unique face is true. rGTrrr)rrrrNrcrr3rD)rprs rrr{Trimesh.unique_faces}sJxxDJJt4EIX ! !"''$**1"= >q AB rucFURURSS-5 g)z Translate the mesh so that all vertex vertices are positive and the lower bound of `self.bounds` will be exactly zero. Alters `self.vertices`. rN)apply_translationrrs rrrezeroTrimesh.rezeros t{{1~45ruc 0[R"U40UD6$)a Split a mesh into multiple meshes from face connectivity. If only_watertight is true it will only return watertight meshes and will attempt to repair single triangle or quad holes. Parameters ---------- mesh : trimesh.Trimesh The source multibody mesh to split only_watertight Only return watertight components and discard any connected component that isn't fully watertight. repair If set try to fill small holes in a mesh, before the discard step in `only_watertight. adjacency : (n, 2) int If passed will be used instead of `mesh.face_adjacency` engine Which graph engine to use for the connected components. kwargs Will be passed to `mesh.submesh` Returns ---------- meshes : (m,) trimesh.Trimesh Results of splitting based on parameters. )rsplitrprqs rrr Trimesh.splits>{{4*6**rucP[R"USS9upX RS'U$)a Find faces that share an edge i.e. 'adjacent' faces. Returns ---------- adjacency : (n, 2) int Pairs of faces which share an edge Examples --------- In [1]: mesh = trimesh.load('models/featuretype.STL') In [2]: mesh.face_adjacency Out[2]: array([[ 0, 1], [ 2, 3], [ 0, 3], ..., [1112, 949], [3467, 3475], [1113, 3475]]) In [3]: mesh.faces[mesh.face_adjacency[0]] Out[3]: TrackedArray([[ 1, 0, 408], [1239, 0, 1]], dtype=int64) In [4]: import networkx as nx In [5]: graph = nx.from_edgelist(mesh.face_adjacency) In [6]: groups = nx.connected_components(graph) T)r` return_edgesface_adjacency_edges)rface_adjacencyrd)rp adjacencyr+s rrrTrimesh.face_adjacencys-H!//TM .3 *+ruc.[R"U5$)z Find faces that share a vertex i.e. 'neighbors' faces. Returns ---------- neighborhood : (n, 2) int Pairs of faces which share a vertex )rface_neighborhoodrs rrrTrimesh.face_neighborhoods&&t,,ruc8URnURS$)z Returns the edges that are shared by the adjacent faces. Returns -------- edges : (n, 2) int Vertex indices which correspond to face_adjacency r)rrdrs rrrTrimesh.face_adjacency_edgess   {{122ruc,[UR5$)z A KDTree for mapping edges back face adjacency index. Returns ------------ tree : scipy.spatial.cKDTree Tree when queried with SORTED edges will return their index in mesh.face_adjacency )r@rrs rrface_adjacency_edges_tree!Trimesh.face_adjacency_edges_treest0011rucdURURn[R"U5nU$)aJ Return the unsigned angle between adjacent faces in radians. Note that if you want a signed angle you can easily use the `face_adjacency_convex` attribute to get a signed angle with advanced indexing: ``` # get a sign per face_adacency pair from the "is it convex" boolean signs = np.array([-1.0, 1.0])[mesh.face_adjacency_convex.astype(np.int64)] # apply the signs to the angles angles = mesh.face_adjacency_angles * signs ``` Returns -------- adjacency_angle : (len(self.face_adjacency), ) float Unsigned angle between adjacent faces corresponding with `self.face_adjacency` )rOrr vector_angle)rppairsangless rrface_adjacency_anglesTrimesh.face_adjacency_angless/2!!$"5"56&&u- ruc2[R"U5nU$)z The projection of the non-shared vertex of a triangle onto its adjacent face Returns ---------- projections : (len(self.face_adjacency), ) float Dot product of vertex onto plane of adjacent triangle. )r adjacency_projections)rp projectionss rrface_adjacency_projections"Trimesh.face_adjacency_projections!s2248 ruc<UR[R:$)aC Return faces which are adjacent and locally convex. What this means is that given faces A and B, the one vertex in B that is not shared with A, projected onto the plane of A has a projection that is zero or negative. Returns ---------- are_convex : (len(self.face_adjacency), ) bool Face pairs that are locally convex )rr$rrs rrface_adjacency_convexTrimesh.face_adjacency_convex0s..::ruc.[R"U5$)z Return the vertex index of the two vertices not in the shared edge between two adjacent faces Returns ----------- vid_unshared : (len(mesh.face_adjacency), 2) int Indexes of mesh.vertices )rface_adjacency_unsharedrs rrrTrimesh.face_adjacency_unshared@s,,T22rucL[R"US9uoRS'U$)z The approximate radius of a cylinder that fits inside adjacent faces. Returns ------------ radii : (len(self.face_adjacency), ) float Approximate radius formed by triangle pair r`face_adjacency_span)rface_adjacency_radiusrd)rpradiis rrrTrimesh.face_adjacency_radiusMs'5:4O4OUY4Z1{{01 ruc8URnURS$)z The approximate perpendicular projection of the non-shared vertices in a pair of adjacent faces onto the shared edge of the two faces. Returns ------------ span : (len(self.face_adjacency), ) float Approximate span between the non-shared vertices r)rrdrs rrrTrimesh.face_adjacency_spanZs  & &{{011rucn[RR[R"URUR R 6SS9n[R"SS/5URR[R5nURU-nX1-R5S-$)z The integral mean curvature, or the surface integral of the mean curvature. Returns --------- area : float Integral mean curvature of mesh rrrg?g?) rlinalgnormr:rMrr;rrastyperrr_)rp edges_lengthsignsrs rrintegral_mean_curvatureTrimesh.integral_mean_curvatureisyy~~ KKt'@'@'B'BC D1& $%d&@&@&G&G&QR++e3%**,s22ruc*[R"US9$)a Returns a networkx graph representing the vertices and their connections in the mesh. Returns --------- graph: networkx.Graph Graph representing vertices and edges between them where vertices are nodes and edges are edges Examples ---------- This is useful for getting nearby vertices for a given vertex, potentially for some simple smoothing techniques. mesh = trimesh.primitives.Box() graph = mesh.vertex_adjacency_graph graph.neighbors(0) > [1, 2, 3, 4] r)rvertex_adjacency_graphrs rrrTrimesh.vertex_adjacency_graph|s.++66rucf[R"UR[UR5S9$)a The vertex neighbors of each vertex of the mesh, determined from the cached vertex_adjacency_graph, if already existent. Returns ---------- vertex_neighbors : (len(self.vertices), ) int Represents immediate neighbors of each vertex along the edge of a triangle Examples ---------- This is useful for getting nearby vertices for a given vertex, potentially for some simple smoothing techniques. >>> mesh = trimesh.primitives.Box() >>> mesh.vertex_neighbors[0] [1, 2, 3, 4] )r+ max_index)r neighborsr7rrMrs rrvertex_neighborsTrimesh.vertex_neighborss$*T%6%6#dmmBTUUruc\UR(agURnURS$)z Does the mesh have consistent winding or not. A mesh with consistent winding has each shared edge going in an opposite direction from the other in the pair. Returns -------- consistent : bool Is winding is consistent or not Fis_winding_consistent)rz is_watertightrdrs rrrTrimesh.is_winding_consistents) ==   {{233rucUR(ag[R"URURS9upX R S'U$)z Check if a mesh is watertight by making sure every edge is included in two faces. Returns ---------- is_watertight : bool Is mesh watertight or not F)r+r4r)rzrrr+r4rd)rp watertightwindings rrrTrimesh.is_watertightsE ==#11**4+<+<  07 +,ruc[UR=(aW UR=(aD [R"UR 5R 5=(a URS:5$)a Check if a mesh has all the properties required to represent a valid volume, rather than just a surface. These properties include being watertight, having consistent winding and outward facing normals. Returns --------- valid Does the mesh represent a volume )rcrrrrrrrrs rr is_volumeTrimesh.is_volumes[    "** " D,,-113 " c!   ruc6URR5$)zw Does the current mesh have data defined. Returns -------- empty : bool If True, no data is set on the current mesh )rbrzrs rrrzTrimesh.is_emptyszz""$$ruchUR(ag[[R"U55nU$)z_ Check if a mesh is convex or not. Returns ---------- is_convex: bool Is mesh convex or not F)rzrcr is_convex)rprs rrrTrimesh.is_convexs) ==))$/0 rucf[URR[R55$)z Return a scipy.spatial.cKDTree of the vertices of the mesh. Not cached as this lead to observed memory issues and segfaults. Returns --------- tree : scipy.spatial.cKDTree Contains mesh.vertices )r@rMrrrrs rrkdtreeTrimesh.kdtrees"t}}))"**566ruheightcV[R"URURUS9$)aW Identify degenerate faces (faces without 3 unique vertex indices) in the current mesh. Usage example for removing them: `mesh.update_faces(mesh.nondegenerate_faces())` If a height is specified, it will identify any face with a 2D oriented bounding box with one edge shorter than that height. If not specified, it will identify any face with a zero normal. Parameters ------------ height : float If specified identifies faces with an oriented bounding box shorter than this on one side. Returns ------------- nondegenerate : (len(self.faces), ) bool Mask that can be used to remove faces )areasr)r nondegenerater)rprs rrr|Trimesh.nondegenerate_facess&0&& NN$//&  ruc2[R"U5nU$)z Return a list of face indices for coplanar adjacent faces. Returns --------- facets : (n, ) sequence of (m, ) int Groups of indexes of self.faces )rfacets)rprs rrrTrimesh.facets+sd# ruc URn[R"URVs/sHn[ X5PM sn[ S9nU$s snf)z Return an array containing the area of each facet. Returns --------- area : (len(self.facets), ) float Total area of each facet (group of faces) rG)rrrrr_r)rprrsrs rr facets_areaTrimesh.facets_area8sD__ dkkBk#jm,kB'R CsAc[UR5S:Xa[R"/5$URn[R"URVs/sHo"XR 5PM sn5nUR UnURURSS2S4UnXPRS'U$s snf)z Return the normal of each facet Returns --------- normals: (len(self.facets), 3) float A unit normal vector for each facet rN facets_origin) rrrrrargmaxrOrMrNrd)rprrsr,roriginss rr facets_normalTrimesh.facets_normalKs t{{ q 88B< __ T[[I[JM0023[IJ##E*-- 1a4 0 78'. O$JsCc8URnURS$)z~ Return a point on the facet plane. Returns ------------ origins : (len(self.facets), 3) float A point on each facet plane r)rrdrs rrrTrimesh.facets_origines   {{?++ruc URRS5nURVs/sHo!URS5PM nnUVs/sHo"[R"USS9PM nnU$s snfs snf)z Return the edges which represent the boundary of each facet Returns --------- edges_boundary : sequence of (n, 2) int Indices of self.vertices )r)rrr) require_count)r4rrr group_rows)rpr+rs edges_facetedges_boundarys rrfacets_boundaryTrimesh.facets_boundaryrsr!!))'2:>++F+QQx''0+ FNYZkH//CDkZGZs A2 !A7cP[UR5S:Xa[R"/[S9$UR nUR nURRR[R5R5n[R"[UR5[S9n[[[U55X5HLupVn[R"XcU- R 5nU["R$:R'5XE'MN U$)z Find which facets of the mesh are on the convex hull. Returns --------- on_hull : (len(mesh.facets), ) bool is A facet on the meshes convex hull or not rrG)rrrrrcrr convex_hullrMrrcopyrziprangerr;r$rr) rprrr on_hullrsnormaloriginrs rrfacets_on_hullTrimesh.facets_on_hulls t{{ q 88Bd+ +$$$$!!**// ;@@B((3t{{+48!$U3w<%8'!K Av&&6/!4!45C /..0GJ "Lru multibodycRUcURS:n[R"XS9 U$)a Find and fix problems with self.face_normals and self.faces winding direction. For face normals ensure that vectors are consistently pointed outwards, and that self.faces is wound in the correct direction for all connected components. Parameters ------------- multibody : None or bool Fix normals across multiple bodies or if unspecified check the current `Trimesh.body_count`. r)r)rVrr~)rprs rrr~Trimesh.fix_normalss+  !+I45 ruc.[R"U5$)z Fill single triangle and single quad holes in the current mesh. Returns ---------- watertight : bool Is the mesh watertight after the function completes )r fill_holesrs rrrTrimesh.fill_holess  &&ruotherc <[R"SXS.UD6up4X44$)aj Align a mesh with another mesh or a PointCloud using the principal axes of inertia as a starting point which is refined by iterative closest point. Parameters ------------ other : trimesh.Trimesh or (n, 3) float Mesh or points in space samples : int Number of samples from mesh surface to align icp_first : int How many ICP iterations for the 9 possible combinations of icp_final : int How many ICP itertations for the closest candidate from the wider search Returns ----------- mesh_to_other : (4, 4) float Transform to align mesh to the other object cost : float Average square distance per point )r`r)r mesh_other)rprrq mesh_to_othercosts rrregisterTrimesh.registers)8+55W4WPVW ""rursigma n_samples thresholdc2[R"UUUUUS9$)a Computes stable orientations of a mesh and their quasi-static probabilities. This method samples the location of the center of mass from a multivariate gaussian (mean at com, cov equal to identity times sigma) over n_samples. For each sample, it computes the stable resting poses of the mesh on a a planar workspace and evaluates the probabilities of landing in each pose if the object is dropped onto the table randomly. This method returns the 4x4 homogeneous transform matrices that place the shape against the planar surface with the z-axis pointing upwards and a list of the probabilities for each pose. The transforms and probabilities that are returned are sorted, with the most probable pose first. Parameters ------------ center_mass : (3, ) float The object center of mass (if None, this method assumes uniform density and watertightness and computes a center of mass explicitly) sigma : float The covariance for the multivariate gaussian used to sample center of mass locations n_samples : int The number of samples of the center of mass location threshold : float The probability value at which to threshold returned stable poses Returns ------- transforms : (n, 4, 4) float The homogeneous matrices that transform the object to rest in a stable pose, with the new z-axis pointing upwards from the table and the object just touching the table. probs : (n, ) float A probability ranging from 0.0 to 1.0 for each pose )r`rr$r%r&)rcompute_stable_poses)rprr$r%r&s rrr(Trimesh.compute_stable_posess'`))#   ru face_index iterationscUbUb [S5eUS- nUS::aSnSn[URS5(a[R"URR 5[ UR5S4:Xa[R"[R"URURR 45URUURS9upVnURR5nUSS2SS24USS2SS24soTlO8[R"URURUURS9upVn[UUUUS S 9nUbURWS 9$U$) aX Subdivide a mesh with each subdivided face replaced with four smaller faces. Will return a copy of current mesh with subdivided faces. Parameters ------------ face_index : (m, ) int or None If None all faces of mesh will be subdivided If (m, ) int array of indices: only specified faces will be subdivided. Note that in this case the mesh will generally no longer be manifold, as the additional vertex on the midpoint will not be used by the adjacent faces to the faces specified, and an additional postprocessing step will be required to make resulting mesh watertight iterations : int If passed will run subdivisions multiple times recursively. NOT COMPATIBLE with `face_index` and will raise a `ValueError` if both arguments are passed. Returns ------------ mesh: trimesh.Trimesh The copy of current mesh with subdivided faces. Nz6Unable to subdivide a subset with multiple iterations!rruvr)rMrNr*rTrFF)rMrNrrTrV)r+)rohasattrrrrr-rrMr subdividehstackrNrTrrK) rpr*r+next_iterationrrMrNattrrZs rrr/Trimesh.subdividesa8  !% !YZZ'!^N"!% 4;; % %"((4;;>>*B   G + %+$4$4DMM4;;>>#BCjj%"&"8"8 % !HT[[%%'F#+1bqb5/8AqrE? Hi%+$4$4jj%"&"8"8 % !HT"    !##~#> > rumax_edgemax_iterr(cSn[URS5(a[R"URR5[ UR 5S4:Xa[R"[R"UR URR45URUUUS9nU(aUupgnOUupgURR5nUSS2SS24USS2SS24sodlO=[R"UR URUUUS9nU(aUupgnOUupg[XgUSS9n U(aU W4$U $)a Subdivide a mesh until every edge is shorter than a specified length. Will return a triangle soup, not a nicely structured mesh. Parameters ------------ max_edge Maximum length of any edge in the result max_iter : int The maximum number of times to run subdivision return_index : bool If True, return index of original face for new faces Returns ------------ mesh: trimesh.Trimesh The copy of current mesh with subdivided faces. Nr-r)rMrNr4r5r(rFFrMrNrrV) r.rrrr-rrMrsubdivide_to_sizer0rNrrK) rpr4r5r(rvertices_facesrMrN final_indexrZs rrr8Trimesh.subdivide_to_sizejs70 4;; % %"((4;;>>*B   G + $55DMM4;;>>#BCjj!!) N/=,"0[[%%'F#+1bqb5/8AqrE? Hi$55jj!!) N/=,"0(PUV ;& & rucn[R"URURUS9up#[ X#SS9$)a Subdivide a mesh by dividing each triangle into four triangles and approximating their smoothed surface using loop subdivision. Loop subdivision often looks better on triangular meshes than catmul-clark, which operates primarily on quads. Parameters ------------ iterations : int Number of iterations to run subdivision. multibody : bool If True will try to subdivide for each submesh Returns ------------ mesh: trimesh.Trimesh The copy of current mesh with subdivided faces. )rMrNr+F)rMrNrV)rsubdivide_looprMrNrK)rpr+ new_verticesrs rrr=Trimesh.subdivide_loops5*#)"7"7]]$**#   uMMrucURR5 URRnS[UR5S[U53nX!;aX$[R "U5nX1U'U$)a Smooth shading in OpenGL relies on which vertices are shared, this function will disconnect regions above an angle threshold and return a non-watertight version which will look better in an OpenGL rendering context. If you would like to use non-default arguments see `graph.smooth_shade`. Returns --------- smooth_shaded : trimesh.Trimesh Non watertight version of current mesh. smooth_shaded_r)r _verify_hashrdhashr smooth_shade)rprr|smooths rr smooth_shadedTrimesh.smooth_shadedsl"   " ""tDKK014:,? <: ##D)c  ruc>[US5(a UR$g)z Get the stored visuals for the current mesh. Returns ------------- visual : ColorVisuals or TextureVisuals Contains visual information about the mesh _visualN)r.rIrs rrrTrimesh.visuals 4 # #<< ruc6Uc [5nXlXlg)z When setting a visual object, always make sure that `visual.mesh` points back to the source mesh. Parameters -------------- visual : ColorVisuals or TextureVisuals Contains visual information about the mesh N)r<r`rIrs rrrrJs = NE  ru plane_normal plane_originc SSKJn SSKJn [R "SUUUSS.UD6upg[ U5S:XagU"U5nU"S0UD6$) aK Returns a 3D cross section of the current mesh and a plane defined by origin and normal. Parameters ------------ plane_normal : (3,) float Normal vector of section plane. plane_origin : (3, ) float Point on the cross section plane. Returns --------- intersections Curve of intersection or None if it was not hit by plane. r) lines_to_path)rET)r`rLrM return_facesrNr)path.exchange.miscrO path.pathrEr mesh_planer) rprLrMrqrOrElines _face_indexpaths rrrTrimesh.section sd( 6%+55 %%     u:?U# ~~ruheightscSSKJn [R"UUUUS9upVnS/[ U5-n[ [ [ U55XuU5H"upp[ U 5S:dMU"XU S.S9X'M$ U$)a Return multiple parallel cross sections of the current mesh in 2D. Parameters ------------ plane_origin : (3, ) float Point on the cross section plane plane_normal : (3) float Normal vector of section plane heights : (n, ) float Each section is offset by height along the plane normal. Returns --------- paths : (n, ) Path2D or None 2D cross sections at specified heights. path.metadata['to_3D'] contains transform to return 2D section back into 3D space. r load_path)r`rLrMrXNr)to_3Dr*)rU) exchange.loadr[rmesh_multiplanerrr) rprMrLrXr[rT transformsrNpathsrsfsegmentsr;s rrsection_multiplaneTrimesh.section_multiplane3 s8 -$1#@#@%% $  5U#!$U3u:%6j!Q A(8}q $XST8UV"R rucapc >[R"SUUUUUS.UD6nU$)ah Slice the mesh with a plane, returning a new mesh that is the portion of the original mesh to the positive normal side of the plane plane_origin : (3,) float Point on plane to intersect with mesh plane_normal : (3,) float Normal vector of plane to intersect with mesh cap : bool If True, cap the result with a triangulated polygon face_index : ((m,) int) Indexes of mesh.faces to slice. When no mask is provided, the default is to slice all faces. Returns --------- new_mesh: trimesh.Trimesh or None Subset of current mesh that intersects the half plane to the positive normal side of the plane )r`rLrMrer*r)rslice_mesh_plane)rprMrLrer*rqnew_meshs rr slice_planeTrimesh.slice_plane` s9<!11 %%!    ruimagec >SSKnURURUR5up4n[ URUU[ XQS9SS9n[ R(Ga[R"URRU5(de[R"URU5(de[R"URURU5(deURSS9n[R"[RU5Vs/sH-oR!S5(dMUS SR#5PM/ sn[$S 9n [R"X5(de[R"[RU5Vs/sH-oR!S 5(dMUS SR#5PM/ sn[$S 9n [R"XRU5(deU$s snfs snf) a Returns a Trimesh object equivalent to the current mesh where the vertices have been assigned uv texture coordinates. Vertices may be split into as many as necessary by the unwrapping algorithm, depending on how many uv maps they appear in. Requires `pip install xatlas` Parameters ------------ image : None or PIL.Image Image to assign to the material Returns -------- unwrapped : trimesh.Trimesh Mesh with unwrapped uv coordinates rN)r-rkFr7obj) file_typezvt rFrGzv r)xatlas parametrizerMrNrKr=r$strictrrrr-exportrstr splitlines startswithrr) rprkrovmaprNr-rZrrLuv_reconv_recons rrunwrapTrimesh.unwrap s&  ,,T]]DJJGR]]4(!R5   :::;;v}}//44 44;;v||U33 33;;v d0CDD DD]]U]3Fxx(+v(>V(>1,,uBU12(>VH;;x,, ,,hh(+v(>U(>1,,tBT12(>UG;;w d(;<< << W Vs)HH+HHc.[R"U5$)z Returns a Trimesh object representing the convex hull of the current mesh. Returns -------- convex : trimesh.Trimesh Mesh of convex hull of current mesh )r r rs rrr Trimesh.convex_hull s!!$''rurJ face_weightcH[R"XUS9upEU(aXE4$U$)a Return random samples distributed across the surface of the mesh Parameters ------------ count : int Number of points to sample return_index : bool If True will also return the index of which face each sample was taken from. face_weight : None or len(mesh.faces) float Weight faces by a factor other than face area. If None will be the same as face_weight=mesh.area Returns --------- samples : (count, 3) float Points on surface of mesh face_index : (count, ) int Index of self.faces )r`rJr~)rsample_surface)rprJr(r~samplesr,s rrrTrimesh.sample s-8 ..   > !ruc:[R"[UR5[S9nSXR '[R"[UR5[ S9n[R"UR55X!'URXS9 g)zM Remove all vertices in the current mesh which are not referenced by a face. rGT)rr6N) rrrrMrcrNrrvr_rx)rprdr6s rrremove_unreferenced_vertices$Trimesh.remove_unreferenced_vertices sk XXc$--0= !% ::((3t}}-U; ii (89 *>ruc[R"[UR5S-[S9R S5nUR URR S55 XlURRS/S9 g)zp Removes all face references so that every face contains three unique vertex indices and no faces are adjacent. rFrGrYrrOrwN) rrvrrNrrrxrdr)rprNs rrunmerge_verticesTrimesh.unmerge_vertices sh  #djj/A-U;CCGL TZZ//34  >"23rur c[R"US[S9nURS:wa [ S5e[ R "U[S5(aU$[R"URUS9n[ R "USS2SS24[S S 9(+nS UR;a/URS /n[R"UU5S Ul U(a[S UR;aK[ R"[R"UR USS95URR"S 'U(a[SUR;aK[ R"[R"UR$USS95URR"S'U(aj[R&"U5(aO[(R*"S5 [R,"[R."UR055UlX l URR31SkS9 URR55 U$)a Transform mesh by a homogeneous transformation matrix. Does the bookkeeping to avoid recomputing things so this function should be used rather than directly modifying self.vertices if possible. Parameters ------------ matrix : (4, 4) float Homogeneous transformation matrix rr)rIrIz%Transformation matrix must be (4, 4)!g:0yE>)r NrFgư>)atolrrrOF)r  translaterPztransform flips winding>r+rVr)r4rMr7r`rOrrPr1r[r2rrrw)rrrrrorr _IDENTITY4rtransform_pointsrM _IDENTITY3rbrrdunitizerOrrP flips_windingr#rascontiguousarrayfliplrrNrid_set)rpr r> has_rotationrs rrapply_transformTrimesh.apply_transform svS@ <<6 !DE E]]6:t 4 4K'77 fU  ==BQB$OO  DJJ &::m45K.??  D  Ndkk904 00%%f1DKK  n - , ;26,,00''%3DKK  . / O99&AA II/ 0--bii .CDDJ%    (  rupitchmethodc 8SSKJn UR"SXUS.UD6$)a Return a VoxelGrid object representing the current mesh discretized into voxels at the specified pitch Parameters ------------ pitch : float The edge length of a single voxel method: implementation key. See `trimesh.voxel.creation.voxelizers` **kwargs: additional kwargs passed to the specified implementation. Returns ---------- voxelized : VoxelGrid object Representing the current mesh r)creation)r`rrr)voxelrvoxelize)rprrrqrs rr voxelizedTrimesh.voxelizedh s"" $  QdQ&QQrupercent face_count aggressionc >SSKJn UUUS.nU"SURR[R 5UR R[R 5S.UR5VVs0sH upgUcM Xg_M snnD6up[XS9$s snnf)a A thin wrapper around `pip install fast-simplification`. Parameters ----------- percent A number between 0.0 and 1.0 for how much face_count Target number of faces desired in the resulting mesh. aggression An integer between `0` and `10`, the scale being roughly `0` is "slow and good" and `10` being "fast and bad." Returns --------- simple : trimesh.Trimesh Simplified version of mesh. r)simplify) target_counttarget_reductionagg)pointsr)rMrNr) fast_simplificationrrMrrrrNryrK) rprrrrrqkvrMrNs rrsimplify_quadric_decimation#Trimesh.simplify_quadric_decimation} s0 1 ' ' # ==%%bjj1jjoobjj1 !' @!tqt@  66As 5 BBface_idsc 2SSKJn [S0U"X40UD6D6$)a Given a list of face indexes find the outline of those faces and return it as a Path3D. The outline is defined here as every edge which is only included by a single triangle. Note that this implies a non-watertight mesh as the outline of a watertight mesh is an empty path. Parameters ------------ face_ids : (n, ) int Indices to compute the outline of. If None, outline of full mesh will be computed. **kwargs: passed to Path3D constructor Returns ---------- path : Path3D Curve in 3D of the outline r) faces_to_pathr)rQrrE)rprrqrs rroutlineTrimesh.outline s. 6@ d??@@rurc ^SSKJn SSKJn SSKJn U"SXS.UD6nUcU"5$U"U5$)a Project a mesh onto a plane and then extract the polygon that outlines the mesh projection on that plane. Parameters ---------- normal : (3,) float Normal to extract flat pattern along origin : None or (3,) float Origin of plane to project mesh onto ignore_sign : bool Allow a projection from the normal vector in either direction: this provides a substantial speedup on watertight meshes where the direction is irrelevant but if you have a triangle soup and want to discard backfaces you should set this to False. rpad : float Proportion to pad polygons by before unioning and then de-padding result by to avoid zero-width gaps. apad : float Absolute padding to pad polygons by before unioning and then de-padding result by to avoid zero-width gaps. tol_dot : float Tolerance for discarding on-edge triangles. precise : bool Use the precise projection computation using shapely. precise_eps : float Tolerance for precise triangle checks. Returns ---------- projected : trimesh.path.Path2D Outline of source mesh rrZ)rD) projected)r`rr)r]r[rVrD path.polygonsr)rprrqr[rDr projections rrrTrimesh.projected s8H - ,BDB6B  8O$$ruc:URR5nU$)zj Summed area of all triangles in the current mesh. Returns --------- area : float Surface area of mesh )rr_)rpareas rrr Trimesh.area s""$ ruc>[R"URS9$)zd The area of each face in the mesh. Returns --------- area_faces : (n, ) float Area of each face )r)rrrrs rrrTrimesh.area_faces s~~d&:&:;;rucURRRSS5nURRRSS5n[R"URUR UUSS9$)a Returns the mass properties of the current mesh. Assumes uniform density, and result is probably garbage if mesh isn't watertight. Returns ---------- properties : dict With keys: 'volume' : in global units^3 'mass' : From specified density 'density' : Included again for convenience (same as kwarg density) 'inertia' : Taken at the center of mass and aligned with global coordinate system 'center_mass' : Center of mass location, in global coordinate system rNrF)rrrr skip_inertia)rbrgetrrr)rprrs rrrTrimesh.mass_properties sd(**//%%i6jjoo))-> ((nn((#   rucUR SUR;aURSS-UlSUR;aURSS-Ul[R"[R "UR 55UlSSS5 URRSS/S9 U$!,(df  N+=f)z Invert the mesh in-place by reversing the winding of every face and negating normals without dumping the cache. Alters `self.faces` by reversing columns, and negating `self.face_normals` and `self.vertex_normals`. rOrrPNrw)rdrOrPrrrrNrrs rrinvertTrimesh.invert) s[[,$(KK$?$$F!4;;.&*kk2B&Cd&J#--bii .CDDJ  >3C"DE [s BB:: Cc [U40UD6$)z Returns a Scene object containing the current mesh. Returns --------- scene : trimesh.scene.scene.Scene Contains just the current mesh r)rs rrscene Trimesh.scene= sT$V$$ruviewerc JUR5nUR"SSU0UD6$)a Render the mesh in an opengl window. Requires pyglet. Parameters ------------ viewer : ViewerType What kind of viewer to use, such as `gl` to open a pyglet window `jupyter` for a jupyter notebook `marimo'` for a marimo notebook None for a "best guess" smooth : bool Run smooth shading on mesh or not, large meshes will be slow Returns ----------- scene : trimesh.scene.Scene Scene with current mesh in it rr)rshow)rprrqrs rrr Trimesh.showH s&2 zz22622rufaces_sequenceonly_watertightrc 8[R"SUUUUS.UD6$)a Return a subset of the mesh. Parameters ------------ faces_sequence : sequence (m, ) int Face indices of mesh only_watertight : bool Only return submeshes which are watertight repair Try to repair the submesh if it is not watertight append : bool Return a single mesh which has the faces appended. if this flag is set, only_watertight is ignored Returns --------- submesh : Trimesh or (n,) Trimesh Single mesh if `append` or list of submeshes )r`rrrr)rsubmesh)rprrrrqs rrrTrimesh.submeshd s06|| )+     ruc.[R"U5$)z Return a float vector which is unique to the mesh and is robust to rotation and translation. Returns ----------- identifier : (7,) float Identifying properties of the current mesh )r identifier_simplers rr identifierTrimesh.identifier s++D11rucB[R"UR5$)z A hash of the rotation invariant identifier vector. Returns --------- hashed : str Hex string of the SHA256 hash from the identifier vector at hand-tuned sigfigs. )r identifier_hashrrs rrrTrimesh.identifier_hash s))$//::rufile_objrnc [SXUS.UD6$)a Export the current mesh to a file object. If file_obj is a filename, file will be written there. Supported formats are stl, off, ply, collada, json, dict, glb, dict64, msgpack. Parameters ------------ file_obj : open writeable file object str, file name where to save the mesh None, return the export blob file_type : str Which file type to export as, if `file_name` is passed this is not required. Returns ---------- exported : bytes or str Result of exporter )r`rrnrr&)rprrnrqs rrrrTrimesh.export s6W9WPVWWrucnSURR5URR5S.$)a Return a dictionary representation of the current mesh with keys that can be used as the kwargs for the Trimesh constructor and matches the schema in: `trimesh/resources/schema/primitive/trimesh.schema.json` Returns ---------- result : dict Matches schema and Trimesh constructor. trimesh)rurMrN)rMtolistrNrs rrto_dictTrimesh.to_dict s1 ,,.ZZ&&(  ruc n[R"U40UD6Vs/sHn[S0UD6PM sn$s snf)z Compute an approximate convex decomposition of a mesh using `pip install pyVHACD`. Returns ------- meshes List of convex meshes that approximate the original **kwargs : VHACD keyword arguments r)r convex_decompositionrKrs rrrTrimesh.convex_decomposition sA(<&Trimesh.eval_cached.. s.AQs eval_cached_)rCextendtuplerdeval)rprrhashabler|rZs rr eval_cachedTrimesh.eval_cached sk,O$...T%/234 ++ ;;s# #i! C ruc2[R"X5nU$)z Concatenate the mesh with another mesh. Parameters ------------ other : trimesh.Trimesh object Mesh to be concatenated with self Returns ---------- concat : trimesh.Trimesh Mesh object of combined result )rr)rprconcats rr__add__Trimesh.__add__ s!!$. ru)rdrbrIrrSrOrNrUrlrrrTrPrMr)NNNNNNNNNTFNNTNN)FNN)F)NNNNNr)r\N)Nrrrr) F)r\rK)FN)r/)NNN)FF)NT)FT)rrKr\rK)__name__ __module__ __qualname____firstlineno__r6r-r/rsr,rcrr:r<r=rsr7rVpropertyrsetterr!rNr"r?rr4rrOrMrPrrrrrrrrr5rrrrrrrrrrrrCr!rrr+r)r7r?r2r4r@rGrMr^rVr[r`rbool_rrjr1rrxr}rrr{rr2rrrrrrrrrrrrrArrrrrrzrrr$rr0r|rrrrr rr~rr(r9r"r(r/r8r=rFrrErrDrcrirBrzr rrrrrrrrrrr+rrr*rr;rr8rrrr3bytesrrrrr.rrrrrrrrrrrrr"r&__static_attributes__rrurrrKrKesM)-%),0.2+/-1:><@-1$(%)6:@D#[X9%[X "[Xy) [X !+ [X i( [X *[X"$sI~"67[X$Di$89[X4S>*[X[X[XD>[XTN[X[X  S'\ 23![X"|^;<=#[X& '[X~$(%) ::D>:TN :  :x " " " ^^ #T #d # ##|##  \\%HY/%D%%, Uj U U1gg.11f%-8I#6%-4%-%-N&,&&"__ Qx 2 Qt Q Q  0  .7Y7477"gen$D!12DD$''"23$''*. 0WW- 0 0 . .t . . 3 3 3 ^^ .V . . . + + + )g ) ), 0,,"$ i$ GG$ 877+; 8 8WW-=0 (3-   ,x(89 , , /(77+;"< / / :77+ : : 5 5 5 +''"2 + + !1   wu~   )GEN ) )gen" WW%5  3gen33  gen   *7 * * j  C$GENB  c     WRXX%6  S$,%)%)+/)-'+ " D>" TN"  ( " g& " G$ "  " N(,BB)$B  BH2525t25hG1iG1R." gbhh/ 6+i+B%%%N -75> - - 3gen 3 3 27 2 2ww'7: GG,<   ;wrxx'8 ; ; 3 3 3 ww'7   2WW%5 2 2333$7770V$tE{"3VV,4t44"t$ 4  ( %$ % % 4   7 7 769YY ( 7288CT 8 WU^,  WW-$ww/2 ,ww/ , ,gen!5  1@Xd^t( 'D '#:w./# ww( )#B37! 6 gg./6 6  6  6 ww!11 2 6 rW[N"9-NBJ7BSN NbNSFF*1FFJF y% 75> 9:: ;FPN'):NiN46 |^'C!DE   ]] HU<+G%HI d  +%+5>+ & +Z++ + + hv  +b*. '' ' ' Y' ' 'R3E3Y3j ( (#26 !!!gg./ !F ?4 [i[D[zRx1R3R.'+(,(, +7(#+7W%+7W% +7  +7ZA 8AfA6+% +%+%Z g   !& !  +! !  ! y$y/) * ! F 2GG, 2 2 ; ; ;"#'XXC=X tUC X: c5d4;.?d3i)P#QQR $ Y &%)! " Y 334" ""  "  " N%)! " Y 334" ""  "  " N%)! " Y 334" ""  "  " H0y0WRXX->0$ 0WW- 0 0 J   0" wu~   U  (4$44PY4l.- S C DrurK)Z__doc__rrnumpyrrrrrr r r r r rrrrrrrrrrrrrrrrrcachingrr r!r" constantsr#r$ exceptionsr%exchange.exportr'parentr(rr*r+typedr,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r> scipy.sparser? scipy.spatialr@rEnetworkxrAPILrB rtree.indexrCrVrDrErrflags writeablerrKrrurrrCs))2ED((%$@?%'%   !!$ VVARZZ ( "  VVARZZ ( " w2jw2?%q!G!!$J%  Q E  Q E  Q E ! a F a F!sx* D87E>E6F F,8E>EEE3!E..E36F<F  FF)F$$F),G 2GG