h5%SrSSKJr SSKJrJrJrJrJrJ r J r J r SSK J r Jr SSKJr SSKrSSKrSSKrSSKJrJrJrJr SSKJr /S QrS rS rS r"S S \5r"SS5r "SS\ 5r!SNSOSjjr"\""5r#SPSS.SQSjjjr$\S.SRSjjr%"SS5r&\S.SSSjjr'\S.STSjjr(\S.STSjjr)\S.STSjjr*SUSjr+SVSjr,SVSjr-SWS jr.\S.SXS!jjr/\S.SYS"jjr0\S#.SZS$jjr1\S#.S[S%jjr2\S#.S\S&jjr3\4S]S'jjr4S^S(jr5SXS)jr6"S*S+\5r7S_S,jr8"S-S.5r9\\ \:S/4\\!4r;S0\S]S7jr?SaS8jr@SbS9jrAScS:jrB\S.SdS;jjrCSeS<jrD"S=S>5rESfS?jrFSeS@jrGSgSAjrHShSBjrISiS`SCjjrJ\4S\SDjjrK"SESF5rLSjSGjrM\4SHjrN\N"54SkSIjjrOSlSJjrP\S.SmSKjjrQSnSaSLjjrRSoSMjrSg)pa EdgeMiner ========= A module for detecting linked edges. The complementary module ezdxf.edgesmith can create entities from the output of this module. Terminology ----------- I try to use the terminology of `Graph Theory`_ but there are differences where I think a different term is better suited for this module like loop for cycle. Edge (in this module) Edge is an immutable class: - unique id - 3D start point (vertex) - 3D end point (vertex) - optional length - optional payload (arbitrary data) The geometry of an edge is not known. Intersection points of edges are not known and cannot be calculated. Vertex A connection point of two or more edges. The degree of a vertex is the number of connected edges. Leaf A leaf is a vertex of degree 1. A leaf is a loose end of an edge, which is not connected to other edges. Junction A junction is a vertex of degree greater 2. A junction has more than two adjacent edges. A junction is an ambiguity when searching for open chains or closed loops. Graph Theory: multiple adjacency Chain A chain has sequential connected edges. The end point of an edge is connected to the start point of the following edge. A chain has unique edges, each edge appears only once in the chain. A chain can contain vertices of degree greater 2. A solitary edge is also a chain. Chains are represented as Sequence[Edge]. Graph Theory: Trail - no edge is repeated, vertex is repeated Simple Chain (special to this module) A simple chain contains only vertices of degree 2, except the start- and end vertex. The start- and end vertices are leafs (degree of 1) or junctions (degree greater 2). Open Chain An open chain is a chain which starts and ends with at leaf. A solitary edge is also an open chain. Graph Theory: Path - no edge is repeated, no vertex is repeated, endings not connected Loop A loop is a simple chain with connected start- and end vertices. A loop has two or more edges. A loop contains only vertices of degree 2. Graph Theory: Cycle - no edge is repeated, no vertex is repeated, endings connected; a loop in Graph Theory is something different Network A network has two or more edges that are directly and indirectly connected. The edges in a network have no order. A network can contain vertices of degree greater 2 (junctions). A solitary edge is not a network. A chain with two or more edges is a network. Networks are represented as Sequence[Edge]. Graph Theory: multigraph; a network in Graph Theory is something different Gap Tolerance Maximum vertex distance to consider two edges as connected Forward Connection An edge is forward connected when the end point of the edge is connected to the start point of the following edge. .. important:: THIS MODULE IS WORK IN PROGRESS (ALPHA VERSION), EVERYTHING CAN CHANGE UNTIL THE RELEASE IN EZDXF V1.4. .. _Graph Theory: https://en.wikipedia.org/wiki/Glossary_of_graph_theory .. _GeeksForGeeks: https://www.geeksforgeeks.org/graph-data-structure-and-algorithms/?ref=shm ) annotations)AnySequenceIteratorIterableDictTuple NamedTupleCallable)Self TypeAlias)CounterN)UVecVec2Vec3distance_point_line_3d)rtree)DepositEdge TimeoutErrorfind_all_loopsfind_all_open_chainsfind_all_sequential_chainsfind_all_simple_chains find_loopfind_loop_by_edgefind_sequential_chainflattenis_chainis_looplength longest_chain reverse_chainshortest_chainsubtract_edges unique_chainsg& .>gN@c@^\rSrSrSr\"54SU4SjjjrSrU=r$)rzB Attributes: solutions: solutions found until time out occur c0>[TU]U5 X lgN)super__init__ solutions)selfmsgr- __class__s A/var/www/html/env/lib/python3.13/site-packages/ezdxf/edgeminer.pyr,TimeoutError.__init__s "r-)r/strr-Sequence[Sequence[Edge]]returnNone) __name__ __module__ __qualname____firstlineno____doc__tupler,__static_attributes__ __classcell__)r0s@r1rrs HMw##r3rcB\rSrSr\4SSjjrSSjr\S Sj5rSr g) WatchdogcDXl[R"5Ulgr*timeouttime perf_counter start_timer.rFs r1r,Watchdog.__init__s% !%!2!2!4r3cDXl[R"5Ulgr*rErJs r1startWatchdog.starts ++-r3c`[R"5UR- UR:$r*)rGrHrIrFr.s r1 has_timed_outWatchdog.has_timed_outs#  "T__4t||CCr3)rIrFN)r7r8)rFfloatr7bool) r9r:r;r<TIMEOUTr,rMpropertyrQr?r3r1rBrBs%&5.DDr3rBc\rSrSr%SrS\S'S\S'S\S'SrS \S 'S rS \S 'SrS\S'SSjr SSjr SSjr SSjr Sr g)ra Represents an immutable edge. An edge can represent any linear curve (line, elliptical arc, spline, ...), but it does not know this shape; only the start and end vertices are stored, not the shape itself. Therefore, the length of the edge must be specified if the length calculation for a sequence of edges should be possible. Intersection points between edges are not known and cannot be calculated. .. Important:: Use only the :func:`make_edge` function to create new edges to get unique ids! Attributes: id: unique id start (Vec3): start vertex end (Vec3): end vertex is_reverse: flag to indicate that the edge is reversed compared to its initial state length: length of the edge, default is 1.0 payload: arbitrary data attached to the edge, default is ``None`` intidrrMendFrU is_reverseg?rSr!Nrpayloadc`[U[5(aURUR:H$g)zpReturn ``True`` if the ids of the edges are equal. .. important:: An edge is equal to its reversed copy! F) isinstancerr\)r.others r1__eq__ Edge.__eq__s' eT " "77ehh& &r3cURnUc[UR5nOI[U[5(a)SSR SUR 55-S-nO [U5nSUS3$)N[,c38# UHn[U5v M g7fr*)repr.0es r1 Edge.__repr__..s%E}!d1gg}]zEdge())r_r5r\ra EdgeWrapperjoinedges)r.r_contents r1__repr__ Edge.__repr__sd,, ?$''lG  - -SXX%Ew}}%EEFLG'lGwiq!!r3cUR$)zThe edge :attr:`id` is used as hash value. An Edge and its reversed edge have the same hash value and cannot both exist in the same :class:`set`. r\rPs r1__hash__ Edge.__hash__s wwr3cURURURURUR(+UR UR 5$)z~Returns a reversed copy. The reversed edge has the same :attr:`id` as the source edge, because they represent the same edge. )r0r\r]rMr^r!r_rPs r1reversed Edge.reversedsB ~~ GG HH JJ  KK LL   r3rXrT)r7r5r7r[)r7r )r9r:r;r<r=__annotations__r^r!r_rcrvrzr}r?rXr3r1rrsJ, G K IJFEGS "  r3rc^UmSU4SjjnU$)Nc>TS- mT$)NrX) next_edge_idsr1next_id"make_id_generator..next_ids r3rrX)rMrrs @r1make_id_generatorrsL Nr3r_c[U5n[U5nUS:aURU5n[[5XSX#5$)zCreates a new :class:`Edge` with a unique id. Args: start: start point end: end point length: default is the distance between start and end payload: arbitrary data attached to the edge gF)rdistancer id_generator)rMr]r!r_s r1 make_edgers> KE s)C |$  E6 CCr3gap_tolc*URU5U:*$)zmThis function should be used to test whether two vertices are close to each other to get consistent results. )rabrs r1iscloser s ::a=G ##r3c\rSrSrSr\S.SSjjr\SSj5rSSjr \SSj5r SSjr SS jr SS jr SSS jjrSS jrSS jrSSjrSSjrSrg)riaThe edge deposit stores all available edges for further searches. The edges and the search index are immutable after instantiation. The :attr:`gap_tol` attribute is mutable. Args: edges: sequence of :class:`Edge` gap_tol: maximum vertex distance to consider two edges as connected Attributes: gap_tol: maximum vertex distance to consider two edges as connected (mutable) rcdX l[U5Ul[UR5Ulgr*)r type_check_edges_SpatialSearchIndex _search_index)r.rtrs r1r,Deposit.__init__ s$% &0&7 0=r3cUR$)z)Sequence of edges stored in this deposit.)rrPs r1rt Deposit.edges%s{{r3c [5n[R"URRUR S9nUR HOnU[U"UR55==S- ss'U[U"UR55==S- ss'MQ [UR5VVs0sH upEXEU-_M snn5$s snnf)adReturns a :class:`Counter` for the degree of all vertices. - :code:`Counter[degree]` returns the count of vertices of this degree. - :code:`Counter.keys()` returns all existing degrees in this deposit A new counter will be created for every method call! The :attr:`gap_tol` attribute is mutable and different gap tolerances may yield different results. radiusr) r functoolspartialrvertices_in_sphererrtlenrMr]items)r.countersearchedgekvs r1degree_counterDeposit.degree_counter*s!( ""    1 1$,, JJD Ctzz*+ , 1 , Ctxx() *a / *gmmo>oda6 o>??>s5C cP[UR5R55$)z;Returns the maximum degree of all vertices in this deposit.)maxrkeysrPs r1 max_degreeDeposit.max_degree?s!4&&(--/00r3cr[URR[U5UR55$)a,Returns the degree of the given vertex. - degree of 0: not in this deposit - degree of 1: one edge is connected to this vertex - degree of 2: two edges are connected to this vertex - degree of 3: three edges ... and so on Check if a vertex exist in a deposit:: if deposit.degree(vertex): ... )rrrrr)r.vertexs r1degreeDeposit.degreeDs*4%%88ft||TUUr3c^[R"URRURS9m[ U4Sj[ R"U555$)z)Returns the degree of the given vertices.rc3F># UHn[T"U55v M g7fr*r)rkrrs r1rm"Deposit.degrees..XsO7NVS((7Ns!)rrrrrr>rgenerate)r.verticesrs @r1degreesDeposit.degreesSsD""    1 1$,, Ot}}X7NOOOr3cR[URRURS9$)aBReturns all unique vertices from this deposit. Ignores vertices that are close to another vertex (within the range of gap_tol). It is not determined which of the close vertices is returned. e.g. if the vertices a, b are close together, you don't know if you get a or b, but it's guaranteed that you only get one of them r)filter_close_verticesrrrrPs r1unique_verticesDeposit.unique_verticesZs!%T%7%7%=%=t||TTr3cUS:a URnURR[U5U5n[ SU55$)zReturns all edges linked to `vertex` in range of `radius`. Args: vertex: 3D search location radius: search range, default radius is :attr:`Deposit.gap_tol` rc38# UHoRv M g7fr*r)rkrs r1rm*Deposit.edges_linked_to..ps.XVVXro)rrrrr>)r.rrrs r1edges_linked_toDeposit.edges_linked_toesA A:\\F%%88fvN.X...r3c^SU4Sjjn[T5mURnURT5nURU5nU(a [ XRS9$g)zReturn the nearest edge to the given vertex. The distance is measured to the connection line from start to end of the edge. This is not correct for edges that represent arcs or splines. c>[TURUR5$![a URR T5s$f=fr*)rrMr]ZeroDivisionErrorr)rrs r1r+Deposit.find_nearest_edge..distanceysC 3-fdjj$((KK$ 3zz**622 3s $%A  A keyNrrr7rS)rrnearest_vertexrmin)r.rrsirrts ` r1find_nearest_edgeDeposit.find_nearest_edgersO 3 f   **62$$^4 u+ +r3c^^^SUUU4SjjnU/m[T5mT(a=TR5nU"UR5 U"UR5 T(aM=[ T5S:aT$[5$)zReturns the network of all edges that are directly and indirectly linked to `edge`. A network has two or more edges, a solitary edge is not a network. c>[TRU55T- nU(a#TRU5 TRU5 ggr*)setrupdateextend)r linked_edgesnetworkr.todos r1process%Deposit.find_network..processs=t33F;+Deposit.find_all_networks..sCFr3r)rrtrrrappenddiscardsort)r.rtnetworksrrs r1find_all_networksDeposit.find_all_networkssz DJJ$&99;D''-G7||(  d#e  * +r3c## URH_n[URUR55S:XaUv M1[URUR55S:XdM[Uv Ma g7f)zUYields all edges that have at least one end point without connection to other edges. rN)rtrrrMr])r.rs r1 find_leafsDeposit.find_leafssWJJD4'' 349 T))$((349 s A$A3* A3)rrrNrtSequence[Edge]r7r8)r7r)r7z Counter[int]r)rrr7r[)rzIterable[UVec]r7z Sequence[int])r7 set[Vec3]))rrrrSr7r)rrr7 Edge | None)rrr7z set[Edge])r7zSequence[set[Edge]])r7Iterator[Edge])r9r:r;r<r=GAP_TOLr,rWrtrrrrrrrrrrr?rXr3r1rrsk :A> @*11 VP U /*,&r3rc@[URURUS9$)zReturns ``True`` if the edges have a forward connection. Forward connection: distance from :attr:`a.end` to :attr:`b.start` <= gap_tol Args: a: first edge b: second edge gap_tol: maximum vertex distance to consider two edges as connected rrr]rMrs r1is_forward_connectedrs 155!''7 33r3c F^[U4Sj[XSS555$)zReturns ``True`` if all edges in the sequence have a forward connection. Args: edges: sequence of edges gap_tol: maximum vertex distance to consider two edges as connected c3<># UHup[XTS9v M g7frN)r)rkrrrs r1rmis_chain..s@UQ73@UsrN)allziprtrs `r1rrs, @CEQRQS9@U r3cj[XS9(dg[USRUSRUS9$)zReturn ``True`` if the sequence of edges is a closed loop. Args: edges: sequence of edges gap_tol: maximum vertex distance to consider two edges as connected rFrr)rrr]rMrs r1r r s. E + 59==%(..' BBr3cL[USRUSRUS9$)zInternal fast loop check.rrrrrs r1 is_loop_fastrs! 59==%(..' BBr3c&[SU55$)z*Returns the length of a sequence of edges.c38# UHoRv M g7fr*)r!rjs r1rmlength..s'Axxro)sumrts r1r!r!s '' ''r3cJ[U[S9nU(aUS$[5$)zReturns the shortest chain of connected edges. .. note:: This function does not verify if the input sequences are connected edges! rrsortedr!r>chains sorted_chainss r1r$r$s%6v.MQ 7Nr3cJ[U[S9nU(aUS$[5$)zReturns the longest chain of connected edges. .. Note:: This function does not verify if the input sequences are connected edges! rrrr s r1r"r"s%6v.MR  7Nr3c[U5nUR5 UVs/sHo"R5PM sn$s snf)zReturns the reversed chain. The sequence order of the edges will be reversed as well as the start- and end points of the edges. )listreverser})chainrtrs r1r#r#s2 KE MMO(- .MMO .. .s<c[U5n[U5S:aU$US/nUSSH]nUSn[XCUS9(aURU5 M*UR 5n[XEUS9(aURU5 M\ U$ U$)aoReturns a simple chain beginning at the first edge. The search stops at the first edge without a forward connection from the previous edge. Edges will be reversed if required to create connection. Args: edges: edges to be examined gap_tol: maximum vertex distance to consider two edges as connected Raises: TypeError: invalid data in sequence `edges` rrNrr)rrrrr})rtrrrlast reversed_edges r1rrs u E 5zA~ 1XJEab Ry G < LL    W E LL '  L Lr3c#d# U(a%[XS9nU[U5SnUv U(aM$gg7f)aYields all simple chains from sequence `edges`. The search progresses strictly in order of the input sequence. The search starts a new chain at every edge without a forward connection from the previous edge. Edges will be reversed if required to create connection. Each chain has one or more edges. Args: edges: sequence of edges gap_tol: maximum vertex distance to consider two edges as connected Raises: TypeError: invalid data in sequence `edges` rN)rr)rtrrs r1rr/s0" %e=c%jl#  %s*00rFc [U5nU(d [5$URn/nUHTn[U5S:a.[ XSS9(aUs $UR [ U55 M@UR US5 MV [XCS9n[UR5S:a [5$[[[XS955$)anReturns the first closed loop in `deposit`. Returns only simple loops, where all vertices have a degree of 2 (only two adjacent edges). .. note:: This is a recursive backtracking algorithm with time complexity of O(n!). Args: deposit (Deposit): edge deposit timeout (float): timeout in seconds Raises: TimeoutError: search process has timed out rrrrr) rr>rrrr_wrap_simple_chainrrtr_find_loop_in_deposit)depositrFr r packed_edgesrs r1rrFs"$G ,F wooG!L u:>E3    25 9 :   a ) l4G 7==Aw .wHI JJr3c[UR5S:a [5$[XS9nUR 5nU(aU$[5$)Nrr)rrtr> LoopFinder find_any_loop)rrFfinderloops r1rrjsA 7==Aw  1F    !D  7Nr3cl[U5nU(d [5$URn/n/nUHcn[U5S:a=[ XcS9(aUR U5 M3UR [ U55 MOUR US5 Me U(dU$[XSS9n[UR5S:a [5$[XS9nURU5 [U5$![a8nUR(a!URUR5 XHl eSnAff=f)aReturns all closed loops from `deposit`. Returns only simple loops, where all vertices have a degree of 2 (only two adjacent edges). The result does not include reversed solutions. .. note:: This is a recursive backtracking algorithm with time complexity of O(n!). Args: deposit (Deposit): edge deposit timeout (float): timeout in seconds Raises: TimeoutError: search process has timed out rrrrrN)rr>rrrrrrrt_find_all_loops_in_depositrr-r_unwrap_simple_chains) rrFr rr-rrresulterrs r1rrus&$G ,F wooG&(I!L u:>E3  '##$6u$=>   a ) l4G 7==Aw+GE V  ++  ==   S]] +%M s C11 D3;3D..D3c/n[XS9nURHnURU5 M URU5 U$)Nr)rrtrr)rrFr-r rs r1r#r#sA')I  1F  d V r3c## [5nUH1n[SU55nX1;dMUv URU5 M3 g7f)zFilter duplicate chains and yields only unique chains. Yields the first chain for chains which have the same set of edges. The order of the edges is not important. c38# UHoRv M g7fr*ryrkrs r1rm unique_chains..s2EDEroN)r frozensetadd)r seenrrs r1r&r&s= !$D2E22 ?K HHSM s %AAc UH8n[U[5(aM[S[[ U5535e U$)Nzexpected type , got )rar TypeErrorr5typertrs r1rrs<$%%8T$Z8IJK K Lr3c$\rSrSr%SrS\S'Srg)_VertexirrrrXN)r9r:r;r< __slots__rr?rXr3r1r4r4sI Jr3r4c([U5nXlU$r*)r4r)locationrrs r1make_edge_vertexr8s X FK Mr3cJ\rSrSrSrS Sjr\S Sj5rS SjrS Sjr Sr g) riz=Spatial search index of all edge vertices. (internal class) c/nUHMnUR[URU55 UR[URU55 MO [R "U5Ulgr*)rr8rMr]rRTree _search_tree)r.rtrrs r1r,_SpatialSearchIndex.__init__sT"$D OO,TZZ> ? OO,TXXt< ="KK1r3cUR$r*r<rPs r1r_SpatialSearchIndex.rtrees   r3cJ[URRX55$)zNReturns all vertices located around `center` with a max. distance of `radius`.)r>r<points_in_sphere)r.centerrs r1r&_SpatialSearchIndex.vertices_in_spheresT&&77GHHr3c@URRU5up#U$)z1Returns the nearest vertex to the given location.)r<nearest_neighbor)r.r7r_s r1r"_SpatialSearchIndex.nearest_vertexs%%66x@  r3r?Nr)r7rtree.RTree[Vec3])rCrrrSr7zSequence[_Vertex])r7rr7r4) r9r:r;r<r=r,rWrrrr?rXr3r1rrs+ 2!!Ir3r.r SearchSolutionscx\rSrSrSr\S.S Sjjr\SSj5rSSjr SSjr SSS jjr SSS jjr SS jr S rg)rizFind closed loops in a :class:`Deposit` by a recursive backtracking algorithm. Finds only simple loops, where all vertices have only two adjacent edges. (internal class) rcr[UR5S:a [S5eXlX l0Ulg)Nrztwo or more edges required)rrt ValueError_deposit_timeout _solutionsr.rrFs r1r,LoopFinder.__init__s0 w}}  !9: :  +-r3c.URR$r*)rNrrPs r1rLoopFinder.gap_tols}}$$$r3cH[URR55$r*)iterrPvaluesrPs r1__iter__LoopFinder.__iter__sDOO**,--r3c,[UR5$r*)rrPrPs r1__len__LoopFinder.__len__ s4??##r3NcUcURRSnURUSS9 [[ UR R 555$![a [5s$f=f)zjReturns the first loop found beginning with the given start edge or an arbitrary edge if `start` is None. rT)stop_at_first_loop) rNrtrnextrVrPrW StopIterationr>)r.rMs r1rLoopFinder.find_any_loopse =MM''*E Ed 3 T__33567 7 7N s+AA10A1c^^URnURmURn[UR5nU4/nU(Ga0UR (a+[ S[URR55S9eUR5nUSnURn URU TS9n [U 5[U5- n U Hn [XRTS9(aU n OU R5n U Rm[TUTS9(aUR!X}4-5 U(a gMj[#UU4SjU55(aMUR%X}4-5 M U(aGM/gg)aSearches for all loops that begin at the given start edge and contain only vertices of degree 2. These are not all possible loops in the edge deposit! Raises: TimeoutError: search process has timed out, intermediate results are attached TimeoutError.data zsearch process has timed outr4rrrNc3N># UHn[TURTS9v M g7frrr]rkrlr last_points r1rm$LoopFinder.search..Ds!INAGJw?"%)rNrrMrBrOrQrr>rPrWrr]rrrr} add_solutionanyr)r.rMr^r start_pointwatchdogrr last_edge end_point candidates survivorsr next_edgerrfs @@r1rLoopFinder.searchs?--,,kk DMM*).z%%"2#DOO$:$:$<=HHJEb I! I 0070KJJ#e*4I!9jj'B $I $ I&]] :{GD%%el&:;)* INKK 45!"dr3cbURn[U5nX2;d[USS9U;agXU'gNTr)rPloop_key)r.r!r-rs r1riLoopFinder.add_solutionIs2OO tn  xd;yH #r3)rNrPrO)rrr7r8)r7rS)r7Iterator[Sequence[Edge]]rr*)rMrr7rF)rMrr^rUr7r8)r!rr7r8)r9r:r;r<r=rVr,rWrrXr[rrrir?rXr3r1rrs?5<.%%.$ ,6\r3rFrucU(a[S[U555nO[SU55nUR[U55nU(a X#SUSU-nU$)zRReturns a normalized key. The key is rotated to begin with the smallest edge id. c38# UHoRv M g7fr*ryr*s r1rmloop_key..Ws8GGroc38# UHoRv M g7fr*ryr*s r1rmr|Ys.GGroN)r>r}indexr)rtridsr~s r1rvrvQsY 888... IIc#h E &kCK' Jr3c [UR5S:a [5$/n[UR5nU(aA[ XR 55nUR U5 U[U5-nU(aMAU$)zReturns all simple chains from `deposit`. Each chains starts and ends at a leaf (degree of 1) or a junction (degree greater 2). All vertices between the start- and end vertex have a degree of 2. The result doesn't include reversed solutions. r)rrtr>rfind_simple_chainrr)rr-rtrs r1rr`sm 7==Aw&(I  E !'99;7 U % r3c0[X5n[X RS9(aU$[XR55n[ U5S:XaU$UR 5 UR 5 UVs/sHoDR5PM snU-$s snf)a Returns a simple chain containing `start` edge. A simple chain start and ends at a leaf or a junction. All connected edges have vertices of degree 2, except the first and last vertex. The first and the last vertex have a degree of 1 (leaf) or greater 2 (junction). rr)_simple_forward_chainrrr}rrr)rrM forward_chainbackwards_chainrs r1rrrs}*'9MM??;+G^^5EFO ?q (7 8MMO 8= HH 8s4Bc|URnU/nUSnURURU5n[U5S:waU$USU:XaUSnOUSn[ URUR US9(aUR U5 OUR UR55 [X2S9(aU$M)zReturns a simple chain beginning with `edge`. All connected edges have vertices of degree 2, expect for the last edge. The last edge has an end-vertex of degree 1 (leaf) or greater 2 (junction). rrrrr) rrr]rrrMrr}r)rrrrrlinkeds r1rrs ooG FE Ry((7; v;! L !9 !9D!9D 488TZZ 9 LL  LL )  /L r3c6[UR[5$)z9Returns ``True`` if `edge` is a wrapper for linked edges.)rar_rrrs r1is_wrapped_chainrs dllK 00r3c[U5S:a [S5e[XS9(a$[XS9(a [S5e[ U5$[S5e)zWraps a sequence of linked edges (simple chain) into a single edge. Two or more linked edges required. Closed loops cannot be wrapped into a single edge. Raises: ValueError: less than two edges; not a chain; chain is a closed loop rz!two or more linked edges requiredrz0closed loop cannot be wrapped into a single edgezedges are not connected)rrMrrr)rrs r1wrap_simple_chainrsN 5zA~<=='  /OP P!%(( . //r3c\[UR[5(a [U5$U4$)z;Unwraps a simple chain which is wrapped into a single edge.)rar_rr_unwrap_simple_chainrs r1unwrap_simple_chainrs%$,, ,,#D)) 7Nr3c&\rSrSrSrSrSSjrSrg)rriz2Internal class to wrap a sequence of linked edges.rc$[U5Ulgr*)r>rt)r.rts r1r,EdgeWrapper.__init__s %*5\ r3Nr)r9r:r;r<r=r5r,r?rXr3r1rrrrs<I2r3rrcr[USRUSR[U5[ U5S9$)Nrrr)rrMr]r!rrrs r1rrs1  ab ve}k%>P r3cURn[U[5(deUR(a%[ S[ UR 555$UR $)Nc3@# UHoR5v M g7fr*)r}rjs r1rm'_unwrap_simple_chain..sC+BaZZ\\+Bs)r_rarrr^r>r}rt)rwrappers r1rrsIllG g{ + ++ + C8GMM+BCCC}}r3c&[SU55$)Nc3J# UHn[[U55v M g7fr*)r>r)rkrs r1rm(_unwrap_simple_chains..s;F5wu~&&Fs!#)r>)r s r1r$r$s ;F; ;;r3c## [U[5(dUHn[U5ShvN M gUn[U5(a[[ U55ShvN gUv gN=N 7f)zNYields all edges from any nested structure of edges as a flat stream of edges.N)rarrrrr2s r1rrs` eT " "Dt} $ $ D ! !3D9: : :J % ;s!)A-A)2A-A+ A-+A-cjU(a[S[U555$[SU55$)zReturns a normalized key.c38# UHoRv M g7fr*ryr*s r1rmchain_key..s9WWroc38# UHoRv M g7fr*ryr*s r1rmrs/WWro)r>r})rtrs r1 chain_keyrs+9%999////r3c[X5nUR5HnURU5 M URnUR SS9 U$)aReturns all open chains from `deposit`. Returns only simple chains ending on both sides with a leaf. A leaf is a vertex of degree 1 without further connections. All vertices have a degree of 2 except for the leafs at the start and end. The result does not include reversed solutions or closed loops. .. note:: This is a recursive backtracking algorithm with time complexity of O(n!). Args: deposit (Deposit): edge deposit timeout (float): timeout in seconds Raises: TimeoutError: search process has timed out c[U5$r*r)xs r1r&find_all_open_chains.. sQr3r)OpenChainFinderrrr-r)rrFr rr-s r1rrsM,W .F""$ d%  I NN'N( r3cL\rSrSr\4S SjjrS SjrS SjrS SjrS Sjr Sr g)ri c\Xl[5Ul/Ul[ U5Ulgr*)rr solution_keysr-rBrlrQs r1r,OpenChainFinder.__init__s$ 365/1 ) r3cHURU5nURU5 gr*)forward_searchreverse_search)r.rforward_chainss r1rOpenChainFinder.searchs ,,T2 N+r3cT^ ^ URnURm URn/nU4/nU(aUR(a [ S5eUR 5nUSR nURU5n[U5[U5- n U (apU Hin[XqRT S9(dUR5nUR m [U U 4SjU55(aMUURXa4-5 Mk OURU5 U(aMU$)Nsearch has timed outrrc3N># UHn[TURTS9v M g7frrdres r1rm1OpenChainFinder.forward_search...s!MR AEE7CUrh)rrrlrQrrr]rrrrMr}rjr) r.rrrlrrrrkrobackwards_edgesrrfs @@r1rOpenChainFinder.forward_searchs,,//==13)-y%%"#9::HHJE)--K 00=J!*oE :O+D"; GL#}}"&JMR EGO4,%%e,)d*r3c`^ ^ URnURm URnUnU(aUR(a[ SUR S9eUR 5nUSRnURU5n[U5[U5- nU(aqUHjn [XiRT S9(dU R5n U Rm [U U 4SjU55(aMUURU 4U-5 Ml OURU5 U(aMgg)Nrr4rrc3N># UHn[TURTS9v M g7frrd)rkrlrnew_start_points r1rm1OpenChainFinder.reverse_search..Js"RWQHRWrh)rrrlrQrr-rrMrrrr]r}rjrri) r.rrrlrrrkrorrrrs @@r1rOpenChainFinder.reverse_search6s,,//==%%"#9T^^TTHHJE(..K 00=J!*oE :O+D";'J#}}'+jjORW TGeO4,!!%()dr3cURn[U5nX2;agURU5 [USS9nX2;agURU5 URR U5 grt)rrr-r-r)r.solutionrrs r1riOpenChainFinder.add_solutionQs[!!! ;   $/ ;    h'r3)rrr-rlN)rr)rrr7r8)rrr7list[tuple[Edge, ...]])rrr7r8)rrr7r8) r9r:r;r<rVr,rrrrir?rXr3r1rr s18* ,<)6 (r3rc^SU4SjjnU$)z[Returns a function that checks if a given sequence of edges has at least `count` vertices. c >[U5T:$r*r)rtcounts r1has_min_edge_count)count_checker..has_min_edge_countcs5zU""r3rtrr7rUrX)rrs` r1 count_checkerr^s # r3c^SU4SjjnU$)z@Returns a function that checks if two input edges are congruent.cN>URRURTS9=(a$ URRURTS9=(dO URRURTS9=(a$ URRURTS9$)N)abs_tol)rMrr])rrrs r1is_congruent_line'line_checker..is_congruent_linelsy GGOOAGGWO 5 6 aeeW 5  GGOOAEE7O 3 8 aggw 7  r3rrrrr7rUrX)rrs` r1 line_checkerris  r3c[UR5n/nU(aUR5nURU5 [UR UR 55nUR UR UR55 URU5 UH#nU"XF5(dMURU5 M% U(aMU$)zReturns all edges from deposit that are not coincident to any other edge in the deposit. Coincident edges are detected by the given `eq_fn` function. ) rrtrrrrMrr]r)req_fnrt unique_edgesrro candidates r1filter_coincident_edgesrxs  E!L yy{D!00<= '11$((;<4 #IT%% i($ % r3c^^[U5n[UR5/5nUHRnURUT5H9mTU;aM [UU4SjU55(aM(UR T5 M; MT U$)aDReturns all vertices from a :class:`RTree` and filters vertices that are closer than radius `gap_tol` to another vertex. Vertices that are close to another vertex are filtered out, so none of the returned vertices has another vertex within the range of `gap_tol`. It is not determined which of close vertices is returned. c3:># UHn[TUTS9v M g7fr)r)rkrrrs r1rm(filter_close_vertices..sNv!wy!W=vs)rrrBrjr-)rtrrmergedrrs ` @r1rrsp r7DTXXZL)F,,VW=IF"NvNNN 9% > Mr3c^^^SUUU4Sjjn[UR5m[UR5T- Rm[ XS9$)aReturns a list of `edges` sorted in counter-clockwise order in relation to the `base` edge. The `base` edge represents zero radians. All edges have to be connected to end-vertex of the `base` edge. This is a pure 2D algorithm and ignores all z-axis values. Args: edges: list of edges to sort base: base edge for sorting, represents 0-radian gap_tol: maximum vertex distance to consider two edges as connected Raises: ValueError: edge is not connected to center c4>[UR5n[UR5nTRU5T::aX!- RnO4TRU5T::aX- RnO[ SU<S35eUT- [ R-$)Nzedge z not connected to center)rrMr]ranglerMmathtau)rsrl edge_angle base_angleconnection_pointrs r1r!sort_edges_to_base..angles   N  $ $Q '7 2%J  & &q )W 4%JuTH,DEF FZ'48833r3rr)rr]rMrr )rtbaserrrrs ` @@r1sort_edges_to_basersB( 4 4DHH~tzz"%55<rrrMr]rrrrr}rr-)rrM clockwiserr chain_setrkrmrnrorpr sorted_edgesrqs r1rrs  7==AwooG GEE I++K "I MM ,,Y,G  Oi/ I A:7N 19-iGTL(, (O ! Iy C!**,I Y 9==+ ?L i - r3cx[SU55nUVs/sHo3RU;dMUPM sn$s snf)zReturns all edges from the iterable `base` that do not exist in the iterable `edges` e.g. remove solutions from the search space. c38# UHoRv M g7fr*ryr*s r1rm!subtract_edges..s-ut77uro)rr\)rrtedge_idsrs r1r%r%s5-u--H! =TTWWH%rsYt#WWW- ?? *    #9 # D DI :I X!" -1DDHD DD$)D>AD D&*1$ggT7> 407 /6 C4;C (  /=D>'. .5<!KH8?+22, 2,"'2,2,l&  d 6"%S/8D>"ABBYYx05 $I&21 9@0&22 < 0(/ $r3