Mi3{ SrSSKrSSKrSSKJrJrJr SSKJ r J r SSK J r SSK JrJrJrJrJrJrJrJrJrJrJr SSKJrJr SS KJr SSK!r"S+S jr#S \\4S jr$S r%Sr&Sr'Sr(S,S\S\\4Sjjr)S-S\*S\*S\\S\S \4 Sjjr+S.S\S\4Sjjr,S/Sjr-S\S \\4Sjr.S\S\S \\\44Sjr/S0S jr0S,S!jr1S1S"jr2S2S#\\S$\\4S%jjr3S/S\S&\\S \\*\*44S'jjr4S(r5S/S)jr6S/S*jr7g!\a@r\R@"\5r\R@"\5r\R@"\5rSrCNSrCff=f!\ar\R@"\5r"SrCGNSrCff=f)3z graph.py ------------- Deal with graph operations. Primarily deal with graphs in (n, 2) edge list form, and abstract the backend graph library being used. Currently uses networkx or scipy.sparse.csgraph backend. N) exceptionsgroupingutil)logtol)faces_to_edges) ArrayLikeGraphEngineTypeIntegerListNDArrayNumberOptionalSequenceTupleUnionint64) coo_matrixcsgraph)cKDTreecUc[USS9up4URSS9 OURnURn[R "USS9n[ U5S:Xa[R"S 5 XEnUSS2S4USS2S4:gnXgnURSS9 U(a+X5SS2S4Un[ U5[ U5:XdeXh4$U$) a: Returns an (n, 2) list of face indices. Each pair of faces in the list shares an edge, making them adjacent. Parameters ----------- faces : (n, 3) int, or None Vertex indices representing triangles mesh : Trimesh object If passed will used cached edges instead of generating from faces return_edges : bool Return the edges shared by adjacent faces Returns ---------- adjacency : (m, 2) int Indexes of faces that are adjacent edges: (m, 2) int Only returned if return_edges is True Indexes of vertices which make up the edges shared by the adjacent faces Examples ---------- This is useful for lots of things such as finding face- connected components: ```python >>> graph = nx.Graph() >>> graph.add_edges_from(mesh.face_adjacency) >>> groups = nx.connected_components(graph_connected) ``` NT) return_indexraxis require_countrz3No adjacent faces detected! Did you merge vertices?) r sort edges_sorted edges_facer group_rowslenrdebug) facesmesh return_edgesedgesr! edge_groups adjacency nondegenerateadjacency_edgess g/var/www/eduai.edurigo.com/storigo/production/storigo_env/lib/python3.13/site-packages/trimesh/graph.pyface_adjacencyr.1sH |+5tD  !!__ %%e1=K ;1 GH 'IadOyA6M(INNNAqD 1- @A?#s9~555)) returnc.URnURU-nURS5 UR5 UR 5n[ R "URSS2S4URSS2S44S[ RS9nU$)a Find faces that share a vertex i.e. 'neighbors' faces. Relies on the fact that an adjacency matrix at a power p contains the number of paths of length p connecting two nodes. Here we take the bipartite graph from mesh.faces_sparse to the power 2. The non-zeros are the faces connected by one vertex. Returns ---------- neighborhood : (n, 2) int Pairs of faces which share a vertex rN)rdtype) faces_sparseTsetdiageliminate_zerostocoonp concatenaterowcolr)r&VTTT neighborhoods r-face_neighborhoodr@s|   B BJJqM B>> 4"&&D/*288L r/c [R"UR[RS9S- nURn[ URR 5Hup4URUn[R"[R"XRSS2S4RS5:HXRSS2S4RS5:H55nURSS9S:HnSXg)SS24'XVXU4'M U$)aN Return the vertex index of the two vertices not in the shared edge between two adjacent faces Parameters ---------- mesh : Trimesh object Input mesh Returns ----------- vid_unshared : (len(mesh.face_adjacency), 2) int Indexes of mesh.vertices for degenerate faces without exactly one unshared vertex per face it will be -1 r3rNrr2rrF) r9 zeros_liker.rface_adjacency_edges enumerater5r% logical_not logical_orreshapesum)r& vid_unsharedr(ifidr%unsharedrow_oks r-face_adjacency_unsharedrPs(==!4!4BHHEIL  % %ED//112 3>> MMq!t,,W55q!t,,W55  1%*$!"'/ QY!3$ r/c UR[R"S5:n[R"S[R"URU5-5nUR UR n[R"USS9RS5nURn[R"[R"UR USS9RS55n[R"U[R"XF5RS5U-5n[R"U5n[R"[!UR"55[R$-n XU- X'X4$)ax Compute an approximate radius between adjacent faces. Parameters -------------- mesh : trimesh.Trimesh Returns ------------- radii : (len(self.face_adjacency),) float Approximate radius between faces Parallel faces will have a value of np.inf span : (len(self.face_adjacency),) float Perpendicular projection distance of two unshared vertices onto the shared edge g{Gz?g@rr)r2rC)face_adjacency_anglesr9radiansabssinverticesrPdiffrIrErunitizesubtract diagonal_dotrow_normonesr#r.inf) r&nonzero denominator point_pairsvectorsr( edges_vecperpspanradiis r-face_adjacency_radiusrgs),((2::d+;;G&&rvvd&@&@&IJJKK-- < <=Kggk*227;G  % %E RWWT]]5%9BJJ7STI ;;$##G7??H9T D == D GGC++, - 6E][0EN ;r/cf[R"5nURUR5 U$)a Returns a networkx graph representing the vertices and their connections in the mesh. Parameters ---------- mesh : Trimesh object 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. >>> graph = mesh.vertex_adjacency_graph >>> graph.neighbors(0) > [1, 3, 4] )nxGraphadd_edges_from edges_unique)r&gs r-vertex_adjacency_graphrns(.  AT&&' Hr/c[R"[U5SS9n[R"[U5SS9n[R"X#[R S9nU$)z Given two sets of faces, find the edges which are in both sets. Parameters --------- faces_a : (n, 3) int Array of faces faces_b : (m, 3) int Array of faces Returns --------- shared : (p, 2) int Edges shared between faces rr operation)r9rr r boolean_rows intersect1d)faces_afaces_be_ae_bshareds r- shared_edgesrysI ''.) 2C ''.) 2C  " "3r~~ FF Mr/enginefacet_thresholdcUc[RnURnURn[R "[ U5[S9n[R"U5[R:nX6XF- S-U:XV'[URU[R"[ UR55SUS9nU$)a6 Find the list of parallel adjacent faces. Parameters ----------- mesh : trimesh.Trimesh engine Which graph engine to use facet_threshold : float Threshold for two facets to be considered coplanar Returns --------- facets : sequence of (n,) int Groups of face indexes of parallel adjacent faces. rBr)nodesmin_lenrz)rr{rgface_adjacency_spanr9r]r#boolrUzeroconnected_componentsr.aranger%)r&rzr{rfreparallelr_ componentss r-facetsr)s(--  & &E  # #Dwws5z.HffTlSXX%G$-7A=OH& H%iiDJJ( J r/only_watertightrepairr*c Uc URnU(aSnOSn[U[R"[ UR 55XdS9nUR "U4XS.UD6$)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. Returns ---------- meshes : (m,) trimesh.Trimesh Results of splitting based on parameters. r)r(r}r~rz)rr)r.rr9rr#r%submesh)r&rrr*rzkwargsr~rs r-splitr\smH'' %ryyTZZ97J << $3 FL r/r~c^^^^ UUU4SjnUUU U4Sjn[R"T[RS9mTc[R"T5m[ T5S:Xa/$[ T5S:Xa-TS::a%[R "TS5R 5$/$[R"TS5(d [S5eS/n[ T5S:aURTR55 [ T5S:aURTR55 [R"U5S-m [R"T [S9nS UT'UTRSS 9nTUm[R "S U4S U445n X9;a X"5$U R#5H n U "5s $ ['S 5e![$a M'f=f)a Find groups of connected nodes from an edge list. Parameters ----------- edges : (n, 2) int Edges between nodes nodes : (m, ) int or None List of nodes that exist min_len : int Minimum length of a component group to return engine : str or None Which graph engine to use (None for automatic): (None, 'networkx', 'scipy') Returns ----------- components : (n,) sequence of (*,) int Nodes which are connected c>[R"T5nTS::aURT5 [R"U5Vs/sHn[ U5PM sn$s snf)z* Find connected components using networkx r)ri from_edgelistadd_nodes_fromrlist)graphrLr(r~r}s r-components_networkx1connected_components..components_networkxsU  ' a<   '!#!8!8!?@!?AQ!?@@@sAc>[TTS9n[R"T[S9nSUT'[R"T[R S9Un[ R"XTS9nUVs/sHoBUPM sn$s snf)z6 Find connected components using scipy.sparse.csgraph ) node_countrBT)r~)connected_component_labelsr9zerosrrrrgroup) labels containedindexrcr(r~rr}s r-components_csgraph0connected_components..components_csgraphss ,EjIHHZt4  % *BHH5i@^^F$5wG ",-*Qa*---s+A<rBrrrCr2redges must be (n, 2)!Trscipynetworkxzno graph engines available!)r9 asanyarrayruniquer#rItolistris_shape ValueErrorappendmaxrrall collections OrderedDictvalues BaseException ImportError) r(r~r}rzrrcountsmaskedges_okenginesfunctionrs ``` @r-rrs2 A$ MM%rxx 0E } %  5zQ Uq a<::eW-446 6I == ( (011SF 5zA~ eiik" 5zA~ eiik"!#J 88Jd +DDKE{A&H (OE%% % &5H(IJG   NN$ : % 3 44   s1G GGcr[X5n[R"USS9up4Ub[U5U:XdeU$)a Label graph nodes from an edge list, using scipy.sparse.csgraph Parameters ----------- edges : (n, 2) int Edges of a graph node_count : int, or None The largest node in the graph. Returns ---------- labels : (node_count,) int Component labels for each node F)directed) edges_to_coorrr#)r(rmatrix _body_countrs r-rrs@ % ,F!66vNK6{j((( Mr/ traversalc [R"USSUSS45nUR[R"USS95SS:nUR 5(aU/nOP[ R "USSS9nUVs/sH-n[R"USS2S4UX&SSS/5PM/ nn[R"UVs/sHRn[U5S :=(a: USUS:g=(a( UR[USUS/55SS:PMT sn5nUR5(aA[R"U5SH$n [R"XIXISS/5XI'M& [R(afUH`n[R"[R"USSUSS45SS9n URU 5SS:R 5(aM`e U$s snfs snf) a Given a traversal as a list of nodes split the traversal if a sequential index pair is not in the given edges. Useful since the implementation of DFS we're using will happily return disconnected values in a flat traversal. Parameters -------------- traversal : (m,) int Traversal through edges edges_tree : cKDTree A way to reconstruct original edge indices from sorted (n, 2) edge values. This is a slight misuse of a kdtree since one could just hash the tuples of the integer edges, but that isn't possible with numpy arrays easily and this allows a vectorized reconstruction. Returns --------------- split : sequence of (p,) int Traversals split into only connected paths. Nr2rrrg|=T)r~ only_nonzeror)r9 column_stackqueryrrrblocksr:arrayr#sortedanyr_rstrict) r edges_tree trav_edgeexistsrrbs needs_closerL check_edges r-_split_traversalrs23B12 ?@I  bggia8 9! ?EH, zzA!CR&!AB%!AJJ$$Z03e;@@BB BB L1  s <4G9AG> traversalsr(c [R"USS9n[U5n[U5S:XaUR 5$/nUHnUR [ XBS95 M [R"UVs/sH!n[R"USSUSS45PM# sn5n[U5S:aCURSS9 UR [R"X[RS95 U$UR 5nU$s snf)a Convert a traversal of a list of edges into a sequence of traversals where every pair of consecutive node indexes is an edge in a passed edge list Parameters ------------- traversals : sequence of (m,) int Node indexes of traversals of a graph edges : (n, 2) int Pairs of connected node indexes Returns -------------- splits : sequence of (p,) int Node indexes of connected traversals rrr)rrNr2rp) r9rrr#copyextendrr vstack_emptyrrrr setdiff1d)rr(rsplitsr}rLincludeds r-fill_traversalsrSs& GGE "EJ :!zz| F &NO   F!SFq"//1Sb61QR5/"BF!STH 8}q 1   h++Er||TU M M"Ts7(D c[R"U[RS9n[U5S:Xa/$[R "US5(d [ S5e[U5R5R5nUS:Xa[RnO"US:Xa[RnO [ S5eURSS 9 [U5n[R"UR!55n[R""US:H5Sn[R""US:5Sn/n[R$"[U5S-[R&S9n[R("XV45HHn X(aMU"X9S S S 9R+[R5n UR-U 5 S X'MJ U$) aP Given an edge list generate a sequence of ordered depth first search traversals using scipy.csgraph routines. Parameters ------------ edges : (n, 2) int Undirected edges of a graph mode : str Traversal type, 'bfs' or 'dfs' Returns ----------- traversals : (m,) sequence of (p,) int Ordered DFS or BFS traversals of the graph. rBrrzedges are not (n, 2)!bfsdfsz(traversal mode must be either dfs or bfsrrF)i_startreturn_predecessorsrT)r9rrr#rrrstrlowerstriprbreadth_first_orderdepth_first_orderrrbincountravelr_rbool_r:astyper) r(modefuncrr nodes_leafr}rvisitedstartordereds r-rrsx" HHU"(( +E 5zQ ]]5' * *011 t9??  " " $D u}** ((CDD JJAJ  E{{5;;=)HHM*1-J JJx!| $Q 'EJhhs8}q(9G  34 >  ee &   '"5 r/c[R"U[RS9n[U5S:Xd'[R "US5(d [ S5eUcUR5S-n[U5nUc"[R"[U5[S9n[X R4URX4S9$)a Given an edge list, return a boolean scipy.sparse.coo_matrix representing the edges in matrix form. Parameters ------------ edges : (n, 2) int Edges of a graph count : int The total number of nodes in the graph if None: count = edges.max() + 1 data : (n,) any Assign data to each edge, if None will be bool True for each specified edge Returns ------------ matrix: (count, count) scipy.sparse.coo_matrix Sparse COO rBrrrr)r3shape)r9rrr#rrrrintr]rrr5r3)r(countdatas r-rrs* MM%rxx 0E J!Ot}}UG<<011 } a JE |wws5z. tWWoTZZ~ NNr/c[R"[5nU(a*UVs/sHoCUSRUS5PM nOBUVs/sH5nX4SRUS5X4SRUS54PM7 nUcUR 5S-n[ U5Vs/sHn[ X55PM nnU$s snfs snfs snf)aK Find the neighbors for each node in an edgelist graph. TODO : re-write this with sparse matrix operations Parameters ------------ edges : (n, 2) int Connected nodes directed : bool If True, only connect edges in one direction Returns --------- neighbors : sequence Vertex index corresponds to set of other vertex indices rr)r defaultdictsetaddrranger)r( max_indexr neighborsedgerLrs r-rrs$'',I5:;UT47   Q (U; Aw  # #DG ,iQ.@.D.DT!W.M N IIK!O ).y)9 :)9AT), )9E : L <  ;s#C 1Q6{mG EJ 6]r{1~  u:?   g &5zQ* %iikGE  % 0 0 2H '78 %  WSb\d5E4F%FG!3%+D r/c/n[R"U5HAupEXSUSUSnUcURU5 M.URXb5 MC U$)a4 Given a MultiDiGraph traversal, collect attributes along it. Parameters ------------- G: networkx.MultiDiGraph traversal: (n) list of (node, instance) tuples attrib: dict key, name to collect. If None, will return all Returns ------------- collected: (len(traversal) - 1) list of attributes rr)rpairwiser)r!rattrib collecteduvattribss r-multigraph_collectr3seI i(aD'!A$-!% >   W %   W_ - ) r/)NNF)NN)TTNN)rNN)N)r)NF)Ng$@)8__doc__rnumpyr9rrr constantsrrgeometryr typedr r r r rrrrrrr scipy.sparserr scipy.spatialrrEExceptionWrapperrrir.r@rPrgrnryrrrrrrrrrrr rrr+r3r/r-r?s%(($    00%(K\wu~2+\.b 8.OS0!0;CF;K0j!%)" 33 3 " 3  3 3nHLf5f55Df5R2<<W <~,,,uXwEV?W,^DN$ONFMQV&!V9A&9IVt;?" "$,Y$7" 4:"J.AHQ0))!,G))!,G,,Q/J 0(  $ $Q 'B(s/D EE  6EE E1E,,E1