hhSSKJr SSKr/SQr\R S5r\R "SS9SSj5r\R "SS9SSj5r\R "SS9S 5r \R "SS9S 5r "S S 5r "S S5r Sr "SS5r"SS\R5rg)) defaultdictN)check_planarity is_planarPlanarEmbeddingc[USS9S$)aReturns True if and only if `G` is planar. A graph is *planar* iff it can be drawn in a plane without any edge intersections. Parameters ---------- G : NetworkX graph Returns ------- bool Whether the graph is planar. Examples -------- >>> G = nx.Graph([(0, 1), (0, 2)]) >>> nx.is_planar(G) True >>> nx.is_planar(nx.complete_graph(5)) False See Also -------- check_planarity : Check if graph is planar *and* return a `PlanarEmbedding` instance if True. F)counterexampler)r)Gs O/var/www/html/env/lib/python3.13/site-packages/networkx/algorithms/planarity.pyrrs< 1U 3A 66T) returns_graphcp[U5nUR5nUcU(a S[U54$gSU4$)aCheck if a graph is planar and return a counterexample or an embedding. A graph is planar iff it can be drawn in a plane without any edge intersections. Parameters ---------- G : NetworkX graph counterexample : bool A Kuratowski subgraph (to proof non planarity) is only returned if set to true. Returns ------- (is_planar, certificate) : (bool, NetworkX graph) tuple is_planar is true if the graph is planar. If the graph is planar `certificate` is a PlanarEmbedding otherwise it is a Kuratowski subgraph. Examples -------- >>> G = nx.Graph([(0, 1), (0, 2)]) >>> is_planar, P = nx.check_planarity(G) >>> print(is_planar) True When `G` is planar, a `PlanarEmbedding` instance is returned: >>> P.get_data() {0: [1, 2], 1: [0], 2: [0]} Notes ----- A (combinatorial) embedding consists of cyclic orderings of the incident edges at each vertex. Given such an embedding there are multiple approaches discussed in literature to drawing the graph (subject to various constraints, e.g. integer coordinates), see e.g. [2]. The planarity check algorithm and extraction of the combinatorial embedding is based on the Left-Right Planarity Test [1]. A counterexample is only generated if the corresponding parameter is set, because the complexity of the counterexample generation is higher. See also -------- is_planar : Check for planarity without creating a `PlanarEmbedding` or counterexample. References ---------- .. [1] Ulrik Brandes: The Left-Right Planarity Test 2009 http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.217.9208 .. [2] Takao Nishizeki, Md Saidur Rahman: Planar graph drawing Lecture Notes Series on Computing: Volume 12 2004 FFNT) LRPlanarity lr_planarityget_counterexampler rplanarity_state embeddings r rr)sE~"!nO,,.I ,Q// /Yr cp[U5nUR5nUcU(a S[U54$gSU4$)z-Recursive version of :meth:`check_planarity`.FrT)rlr_planarity_recursiveget_counterexample_recursivers r check_planarity_recursiverusD"!nO668I 6q99 9Yr c|[R"U5n[U5S(a[R"S5e[R"5nUHan[ X5nUHKnUR X$5 [U5S(dM)UR X$5 UR X$5 MM Mc U$)aObtains a Kuratowski subgraph. Raises nx.NetworkXException if G is planar. The function removes edges such that the graph is still not planar. At some point the removal of any edge would make the graph planar. This subgraph must be a Kuratowski subgraph. Parameters ---------- G : NetworkX graph Returns ------- subgraph : NetworkX graph A Kuratowski subgraph that proves that G is not planar. r!G is planar - no counter example.)nxGraphrNetworkXExceptionlist remove_edgeadd_edger subgraphunbrsvs r rrs*  Aq!""#FGGxxzH ADzA MM! q!!$$ 1 !!!'  Or c|[R"U5n[U5S(a[R"S5e[R"5nUHan[ X5nUHKnUR X$5 [U5S(dM)UR X$5 UR X$5 MM Mc U$)z0Recursive version of :meth:`get_counterexample`.rr)rrrrrrr r!s r rrs  A #A&""#FGGxxzH ADzA MM! (+A.. 1 !!!'  Or c4\rSrSrSrS SjrSrSrSrSr g) IntervalzRepresents a set of return edges. All return edges in an interval induce a same constraint on the contained edges, which means that all edges must either have a left orientation or all edges must have a right orientation. NcXlX lgNlowhigh)selfr-r.s r __init__Interval.__init__s  r cHURSL=(a URSL$)zCheck if the interval is emptyNr,r/s r emptyInterval.emptysxx45DII$55r cB[URUR5$)zReturns a copy of this interval)r(r-r.r3s r copy Interval.copys$)),,r cUR5(+=(a) URURURU:$)z0Returns True if interval I conflicts with edge b)r4lowptr.)r/brs r conflictingInterval.conflictings=  L%%dii0?3H3H3KK r )r.r-)NN) __name__ __module__ __qualname____firstlineno____doc__r0r4r7r<__static_attributes__r r r(r(s6- r r(cF\rSrSrSr\"5\"54SjrSrSrSr g) ConflictPairzRepresents a different constraint between two intervals. The edges in the left interval must have a different orientation than the one in the right interval. cXlX lgr+leftright)r/rJrKs r r0ConflictPair.__init__s   r cJURnURUlXlg)zSwap left and right intervalsNrI)r/temps r swapConflictPair.swapsyyJJ  r cURR5(a#URURR$URR5(a#URURR$[ URURRURURR5$)z.Returns the lowest lowpoint of a conflict pair)rJr4r:rKr-min)r/rs r lowestConflictPair.lowests 99??  "((8 8 ::    "((7 7  ! !$))-- 0/2G2G 2W  r rIN) r>r?r@rArBr(r0rOrSrCrDr r rFrFs! %Jhj  r rFcU(dgUS$)z(Returns the element on top of the stack.NrD)ls r top_of_stackrXs  R5Lr cn\rSrSrSr/SQrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrg)riz5A class to maintain the state during planarity check.)r rootsheightr:lowpt2 nesting_depth parent_edgeDGadjs ordered_adjsrefsideS stack_bottom lowpt_edgeleft_ref right_refrc[R"5UlURRUR5 UR H3nUSUS:wdMURR USUS5 M5 /Ul[S5Ul 0Ul 0Ul 0Ul [S5Ul [R"5UlURRUR5 0Ul0Ul[S5Ul[S5Ul/Ul0Ul0Ul0Ul0Ul[35Ulg)Nrcgr+rDrDr r &LRPlanarity.__init__..%s$r cgr+rDrDr r rlrm,str cgr+rDrDr r rlrm5str cg)NrjrDrDr r rlrm6sr )rrr add_nodes_fromnodesedgesr rZrr[r:r\r]r^DiGraphr_r`rarbrcrdrerfrgrhrr)r/r es r r0LRPlanarity.__init__s agg&Atqt|!ad+ ",/   '|4**, qww' |, *  (*r c^^TRR5S:a=TRR5STRR5-S- :agTRH(m[TRT5TRT'M* TRHPmTR TbMSTR T'TR RT5 TRT5 MR STlSTl STlTRH,m[TRTUU4SjS9TRT'M. TR HmTRT5(aM g STlSTlSTlSTlSTlTRR$H1nTR'U5TR(U-TR(U'M3 TR*R-TRR.5 TRH`m[TRTUU4SjS9TRT'SnTRTHnTR*R1TX2S 9 UnM! Mb STl STlSTlTR HmTR5T5 M STlSTlSTl STlSTlSTlTR*$) zExecute the LR planarity test. Returns ------- embedding : dict If the graph is planar an embedding is returned. Otherwise None. Nrc&>TRTU4$r+r]xr/r%s r rl*LRPlanarity.lr_planarity..b$*<*TRTU4$r+r|r}s r rlrvrr ccw)r ordersizerr`r[rZappenddfs_orientationr\r_sortedra dfs_testingr:rdrerfrssignr]rrqrr add_half_edgerb dfs_embeddingr^rgrhrcr/ru previous_nodewr%s` @r rLRPlanarity.lr_planarityBst 66<<>A $&&++-!dfflln2Dq2H"HAq ?DIIaLA{{1~%!" A !!!$$$Q'   A#) D$D  a  A##A&&    A$(IIaL43E3Ea3H$HD  q ! %%dggmm4A#) D$D  a !M&&q),,Q,E ! *!A   q !    ~~r c^^TRR5S:a=TRR5STRR5-S- :agTRHPmTRTbMSTRT'TRR T5 TR T5 MR STlTRH,m[TRTUU4SjS9TRT'M. TRHmTRT5(aM g TRRH1nTRU5TRU-TRU'M3 TRRTRR 5 TRH`m[TRTUU4SjS9TRT'SnTRTHnTRR#TX2S 9 UnM! Mb TRHmTR%T5 M TR$) z*Recursive version of :meth:`lr_planarity`.rxryrzNrc&>TRTU4$r+r|r}s r rl4LRPlanarity.lr_planarity_recursive..rr rc&>TRTU4$r+r|r}s r rlrrr r)r rrr[rZrdfs_orientation_recursiver_rradfs_testing_recursiverssign_recursiver]rrqrrrdfs_embedding_recursivers` @r r"LRPlanarity.lr_planarity_recursives 66<<>A $&&++-!dfflln2Dq2H"HA{{1~%!" A !!!$..q1 A#) D$D  a  A--a00A$($7$7$:T=O=OPQ=R$RD  q ! %%dggmm4A#) D$D  a !M&&q),,Q,E ! *A  ( ( +~~r cU/n[S5n[S5nU(GaUR5nURUnURUX1SGHnX4nXG(GdX4URR ;dXa4URR ;aX1==S- ss'MUURR X5 URUURU'URUURU'URUcVXpRU'URUS-URU'URU5 URU5 SXG' GO}URUURU'SURU-URU'URUURU:aURU==S- ss'UbURUURU:aP[URUURU5URU'URUURU'OURUURU:a4[URUURU5URU'O3[URUURU5URU'X1==S- ss'GM U(aGMgg)z=Orient the graph by DFS, compute lowpoints and nesting order.cgNrrDrDr r rl-LRPlanarity.dfs_orientation..!r cgNFrDrDr r rlrr NrjTrx) rpopr^r`r_rsr r[r:r\rr]rR)r/r% dfs_stackind skip_initrurvws r rLRPlanarity.dfs_orientations\C )$ .  A  #AYYq\#&(+V }}v.1&DGGMM2I!  GG$$Q*%)[[^DJJrN&*kk!nDKKO{{1~-.0((+)-Q!); A!((+!((+(, )-Q 2*+TZZ^);""2&;;r?T[[^3&&r*a/*=zz"~ 1 5),TZZ]DKKO)L A(, 2 1 B$**Q-7),T[[^TZZ^)L A),T[[^T[[_)M A! M, ir cURUnURUGHTnX4URR;dX14URR;aM<X4nURR X5 UR UUR U'UR UURU'UR Uc?X@RU'UR US-UR U'URU5 OUR UUR U'SUR U-URU'URUUR U:aURU==S- ss'UcGMYUR UUR U:aR[UR UURU5URU'UR UUR U'GMUR UUR U:a6[URUUR U5URU'GM![URUURU5URU'GMW g)z-Recursive version of :meth:`dfs_orientation`.Nrjrx) r^r r_rsr r[r:r\rr]rR)r/r%rurrs r r%LRPlanarity.dfs_orientation_recursives   Q Av&1&DGGMM*AB GG  Q "![[^DJJrN"kk!nDKKO{{1~%&(  #!%Q!!3 A..q1!%Q 2&'B%7D  r "{{2Q/""2&!+&}::b>DJJqM1%(A B%HDKKN$(JJrNDJJqMZZ^djjm3%(QB%HDKKN%(QR%IDKKN9r c BU/n[S5n[S5nU(Ga|UR5nURUnSnURUX1SGHnX4nXH(d[ UR 5UR U'XRU:Xa*URU5 URU5 SXH'Sn OXRU'UR R[[X5S95 URUURU:aJXpRUS:XaURUURU'OURX5(d gX1==S- ss'GM U(dUbURU5 U(aGM|g) zTest for LR partition.cgrrDrDr r rl)LRPlanarity.dfs_testing..rr cgrrDrDr r rlrrr FNTrKrrj)rrr^rarXrdrerrfrFr(r:r[add_constraintsremove_back_edges) r/r%rrrru skip_finalreis r rLRPlanarity.dfs_testingssC )$ .  A  #AJ&&q)#&(3V },8,@D%%b)--a00!((+!((+(, %) .0+ l"9I&JK::b>DKKN2--a033-1__R-@*#33B::#(! 346=**1-IiLr c bURUnURUHnX4n[UR5URU'X@RU:XaUR U5(d gO9X@R U'URR[[XD5S95 URUURU:dMX0RUS:XaUR UUR U'MURXB5(aM g UbURU5 g)z)Recursive version of :meth:`dfs_testing`.FrrT)r^rarXrdrerrfrrFr(r:r[rr)r/r%rurrs r r!LRPlanarity.dfs_testing_recursiveGs    Q ""1%AB$0$8D  b !%%a((11!44 5')# l"1ABCzz"~ A.))!,Q//)-)>66<<>>zz!''++&A677==??ggllnAG,-GGLLDHHQWW[[)ggkk (,(:%DFF#t'8'8'<<!$466"''33B== FFB % B%B& Aww""2,,ww""2,,$%GGLLDHHQWW[[ !ww{{&ggkk vv||~~'(vv{{$AFFJ#466"''33B== FFB % B%B&B&& 177==?? FFMM! r cUSnUR(a[UR5RU5URU:XaURR 5nUR R b#SURUR R 'UR(a7[UR5RU5URU:XaMUR(GaURR 5nUR RbUR RSU:XahURUR RUR lUR RbUR RSU:XaMhUR RcUR R bkURR URUR R 'SURUR R 'SUR lURRbURRSU:XahURURRURlURRbURRSU:XaMhURRcURR bkUR R URURR 'SURURR 'SURlURRU5 URUURU:a[UR5R Rn[UR5RRnUb2Ub URUURU:aX@RU'gXPRU'gg)NrrVrj) rdrXrSr[rrJr-rcr.rbrKrr:)r/rur#rhlhrs r rLRPlanarity.remove_back_edgess aDffdff-44T:dkk!nL Avvzz%(* !&&**%ffdff-44T:dkk!nL 666 A&&++)affkk!n.A"hhqvv{{3 &&++)affkk!n.Avv{{"qvvzz'='(ww{{$(* !&&**%! '',,*qww||A!/C#xx 5 '',,*qww||A!/Cww||# (?() %)+ !''++&" FFMM!  ::a=4;;q> )dff%**//Bdff%++00B~2:B$**R.1P     *r cxU/n[S5nU(Ga#UR5nURUX1SHnX1==S- ss'X4nXPRU:Xa[URR XA5 X@R U'X@RU'URU5 URU5 OuURUS:Xa)URRXAURUS9 MURRXAUR US9 XR U'M U(aGM"gg)zCompletes the embedding.cgrrDrDr r rl+LRPlanarity.dfs_embedding..rr Nrjrcw) rrrar^radd_half_edge_firstrgrhrrcr)r/r%rrrrs r rLRPlanarity.dfs_embeddingsC )$ A&&q)#&(3! V))!,,NN66q<'(MM!$()NN1%$$Q'$$Q'yy})44Qt~~a?P4Q44QdmmA>N4O+, a(#4ir cURUHnX4nX0RU:XaJURRX!5 X RU'X R U'UR U5 MbURUS:Xa)URRX!UR US9 MURRX!URUS9 XRU'M g)z+Recursive version of :meth:`dfs_embedding`.rjrrN) rar^rrrgrhrrcr)r/r%rrs r r#LRPlanarity.dfs_embedding_recursives""1%AB%%a((2218#$ a $%q!,,Q/99R=A%NN004>>!;L0MNN00$--:J0K'(MM!$&r cU/n[S5nU(aUR5nURUbPURU5 URURU5 URUX1'SURU'O&URU==URX1-ss'U(aMURU$)z:Resolve the relative side of an edge to the absolute side.cgr+rDrDr r rl"LRPlanarity.sign..sdr N)rrrbrrc)r/rurold_refs r rLRPlanarity.signsC l+ Axx{&  #  !-!XXa[ "  !  '* 55 iyy|r cURUbJURUURURU5-URU'SURU'URU$)z"Recursive version of :meth:`sign`.N)rbrcr)r/rus r rLRPlanarity.sign_recursivesX 88A; "99Q<$*=*=dhhqk*JJDIIaLDHHQKyy|r )r_r rdr`rr[rgr:r\rfr]rar^rbrhrZrcreN)r>r?r@rArB __slots__r0rrrrrrrrrrrrrCrDr r rrsW?I*&+PM^-^3jJB/b6*X%!N-:)$(r rc^\rSrSrSrSU4SjjrSrSrSrSr S r S r SSS .U4S jjr S r SrSrSrSrSrSrSrSSjrSrSU4SjjrSrU=r$)ria Represents a planar graph with its planar embedding. The planar embedding is given by a `combinatorial embedding `_. .. note:: `check_planarity` is the preferred way to check if a graph is planar. **Neighbor ordering:** In comparison to a usual graph structure, the embedding also stores the order of all neighbors for every vertex. The order of the neighbors can be given in clockwise (cw) direction or counterclockwise (ccw) direction. This order is stored as edge attributes in the underlying directed graph. For the edge (u, v) the edge attribute 'cw' is set to the neighbor of u that follows immediately after v in clockwise direction. In order for a PlanarEmbedding to be valid it must fulfill multiple conditions. It is possible to check if these conditions are fulfilled with the method :meth:`check_structure`. The conditions are: * Edges must go in both directions (because the edge attributes differ) * Every edge must have a 'cw' and 'ccw' attribute which corresponds to a correct planar embedding. As long as a PlanarEmbedding is invalid only the following methods should be called: * :meth:`add_half_edge` * :meth:`connect_components` Even though the graph is a subclass of nx.DiGraph, it can still be used for algorithms that require undirected graphs, because the method :meth:`is_directed` is overridden. This is possible, because a valid PlanarGraph must have edges in both directions. **Half edges:** In methods like `add_half_edge` the term "half-edge" is used, which is a term that is used in `doubly connected edge lists `_. It is used to emphasize that the edge is only in one direction and there exists another half-edge in the opposite direction. While conventional edges always have two faces (including outer face) next to them, it is possible to assign each half-edge *exactly one* face. For a half-edge (u, v) that is oriented such that u is below v then the face that belongs to (u, v) is to the right of this half-edge. See Also -------- is_planar : Preferred way to check if an existing graph is planar. check_planarity : A convenient way to create a `PlanarEmbedding`. If not planar, it returns a subgraph that shows this. Examples -------- Create an embedding of a star graph (compare `nx.star_graph(3)`): >>> G = nx.PlanarEmbedding() >>> G.add_half_edge(0, 1) >>> G.add_half_edge(0, 2, ccw=1) >>> G.add_half_edge(0, 3, ccw=2) >>> G.add_half_edge(1, 0) >>> G.add_half_edge(2, 0) >>> G.add_half_edge(3, 0) Alternatively the same embedding can also be defined in counterclockwise orientation. The following results in exactly the same PlanarEmbedding: >>> G = nx.PlanarEmbedding() >>> G.add_half_edge(0, 1) >>> G.add_half_edge(0, 3, cw=1) >>> G.add_half_edge(0, 2, cw=3) >>> G.add_half_edge(1, 0) >>> G.add_half_edge(2, 0) >>> G.add_half_edge(3, 0) After creating a graph, it is possible to validate that the PlanarEmbedding object is correct: >>> G.check_structure() Nc >[TU]"SSU0UD6 URUlURUlURUlg)Nincoming_graph_datarD)superr0_PlanarEmbedding__forbiddenr add_edges_fromadd_weighted_edges_from)r/rattr __class__s r r0PlanarEmbedding.__init__ZsB I-@IDI(( "..'+'7'7$r c[S5e)zjForbidden operation Any edge additions to a PlanarEmbedding should be done using method `add_half_edge`. z=Use `add_half_edge` method to add edges to a PlanarEmbedding.)NotImplementedError)r/argskwargss r __forbiddenPlanarEmbedding.__forbidden`s " K  r cT0nUHn[URU55X'M! U$)zConverts the adjacency structure into a better readable structure. Returns ------- embedding : dict A dict mapping all nodes to a list of neighbors sorted in clockwise order. See Also -------- set_data )rneighbors_cw_order)r/rr%s r get_dataPlanarEmbedding.get_datajs0 A 7 7 :;ILr cfUH+nSn[X5HnURX$US9 UnM M- g)a Inserts edges according to given sorted neighbor list. The input format is the same as the output format of get_data(). Parameters ---------- data : dict A dict mapping all nodes to a list of neighbors sorted in clockwise order. See Also -------- get_data Nr)reversedr)r/datar%rbrs r set_dataPlanarEmbedding.set_data}s< ACdg&""1C"0'r cURUHGnURUnX1SnX1SnX1 URUU X:wdM9XSUS'XCUS'MI URU URU URU [R "U5 g![a n[R "SUS35UeSnAff=f)a\Remove node n. Removes the node n and all adjacent edges, updating the PlanarEmbedding to account for any resulting edge removal. Attempting to remove a non-existent node will raise an exception. Parameters ---------- n : node A node in the graph Raises ------ NetworkXError If n is not in the graph. See Also -------- remove_nodes_from rrz The node is not in the planar embedding.N)_pred_succ_nodeKeyErrorr NetworkXError _clear_cache)r/nr#succs_uun_cwun_ccwerrs r remove_nodePlanarEmbedding.remove_nodes, ZZ]**Q- 4( E*JJJqM!$:,2EN5),1FOD)# 1  1  1   ""A3>?  sAB 9B C$B??CcZUH%nX R;dMURU5 M' g)aRemove multiple nodes. Parameters ---------- nodes : iterable container A container of nodes (list, dict, set, etc.). If a node in the container is not in the graph it is silently ignored. See Also -------- remove_node Notes ----- When removing nodes from an iterator over the graph you are changing, a `RuntimeError` will be raised with message: `RuntimeError: dictionary changed size during iteration`. This happens when the graph's underlying dictionary is modified during iteration. To avoid this error, evaluate the iterator into a separate object, e.g. by using `list(iterator_of_nodes)`, and pass this object to `G.remove_nodes_from`. N)rr)r/rrrs r remove_nodes_from!PlanarEmbedding.remove_nodes_froms%0AJJ  #r c## URUnU(dg[[U55nUv X#SnX4:waUv X$SnX4:waMgg7f)zjGenerator for the neighbors of v in clockwise order. Parameters ---------- v : node Yields ------ node Nr)rnextr)r/r%succs start_node current_nodes r r"PlanarEmbedding.neighbors_cw_orders\ 1  (5/* (. (  .t4L(s A AArrc>URRU5nU(a[[URU55nUb\X5;a[R "S5eUb[R "S5eXSSn[ T U]XX7S9 X%US'X%US'X6:gnOZUbAXE;a[R "S5eXTSn [ T U]XXS9 X%U S'X%US'SnO[R "S 5eU(aURU5XV'ggUcUb[R "S 5e[ T U]XX"S 9 g) aAdds a half-edge from `start_node` to `end_node`. If the half-edge is not the first one out of `start_node`, a reference node must be provided either in the clockwise (parameter `cw`) or in the counterclockwise (parameter `ccw`) direction. Only one of `cw`/`ccw` can be specified (or neither in the case of the first edge). Note that specifying a reference in the clockwise (`cw`) direction means inserting the new edge in the first counterclockwise position with respect to the reference (and vice-versa). Parameters ---------- start_node : node Start node of inserted edge. end_node : node End node of inserted edge. cw, ccw: node End node of reference edge. Omit or pass `None` if adding the first out-half-edge of `start_node`. Raises ------ NetworkXException If the `cw` or `ccw` node is not a successor of `start_node`. If `start_node` has successors, but neither `cw` or `ccw` is provided. If both `cw` and `ccw` are specified. See Also -------- connect_components Nz!Invalid clockwise reference node.z$Only one of cw/ccw can be specified.rrrz(Invalid counterclockwise reference node.TzLNode already has out-half-edge(s), either cw or ccw reference node required.zInvalid reference node.)rr) rgetrrrrrr r) r/rend_noderrr leftmost_nbrref_ccwmove_leftmost_nbr_to_endref_cwrs r rPlanarEmbedding.add_half_edgesbD z* J)? @AL~?**+NOO?**+QRR)E* " J'/gt$#+b % ,.+=(#**+UVVD) & J'/f e$#+c 4 +/(&&b(',ii &=# (~&&'@AA G Zx  Mr cUHn[URU55n[X5nX%:waSn[R"U5eXH1nUR Xa5(aMSn[R"U5e M [5n[R "U5Hn[U5S:XaM[U5n Sn Sn UH@nURU5H(nU S- n X4U;dMU S- n URXU5 M* MB U S-n X- U -S:wdM{Sn[R"U5e g![a!nSU3n[R"U5UeSnAff=f) aRuns without exceptions if this object is valid. Checks that the following properties are fulfilled: * Edges go in both directions (because the edge attributes differ). * Every edge has a 'cw' and 'ccw' attribute which corresponds to a correct planar embedding. Running this method verifies that the underlying Graph must be planar. Raises ------ NetworkXException This exception is raised with a short explanation if the PlanarEmbedding is invalid. z5Bad embedding. Missing orientation for a neighbor of Nz3Bad embedding. Edge orientations not set correctly.z-Bad embedding. Opposite half-edge is missing.rjrrxz7Bad embedding. The graph does not match Euler's formula) setrrrrhas_edgeconnected_componentslen traverse_face) r/r% sorted_nbrsrmsg unsorted_nbrsrcounted_half_edges component num_nodesnum_half_edges num_faces num_edgess r check_structurePlanarEmbedding.check_structure;st$A 9!$"9"9!"<=  LM+K**3//W}}Q**IC..s33 $!U006I9~"IINI003A"a'Nv%77!Q **11CD 4'!+I$y0A5O**3//'7! 9MaSQ**3/S8 9sD>> E)E$$E)c$URXUS9 g)aAdds a half-edge from start_node to end_node. The half-edge is added counter clockwise next to the existing half-edge (start_node, reference_neighbor). Parameters ---------- start_node : node Start node of inserted edge. end_node : node End node of inserted edge. reference_neighbor: node End node of reference edge. Raises ------ NetworkXException If the reference_neighbor does not exist. See Also -------- add_half_edge add_half_edge_cw connect_components rNrr/rrreference_neighbors r add_half_edge_ccw!PlanarEmbedding.add_half_edge_ccwus6 :4FGr c$URXUS9 g)aAdds a half-edge from start_node to end_node. The half-edge is added clockwise next to the existing half-edge (start_node, reference_neighbor). Parameters ---------- start_node : node Start node of inserted edge. end_node : node End node of inserted edge. reference_neighbor: node End node of reference edge. Raises ------ NetworkXException If the reference_neighbor does not exist. See Also -------- add_half_edge add_half_edge_ccw connect_components rNrrs r add_half_edge_cw PlanarEmbedding.add_half_edge_cws4 :5GHr cURUnURUnX2SnX2SnXASnXASnX2 URUU XA URUU X%:waXcUS'XSUS'X:waXUS'XtUS'[R "U5 g![a#n [R"SUSUS35U eSn A ff=f)a-Remove the edge between u and v. Parameters ---------- u, v : nodes Remove the half-edges (u, v) and (v, u) and update the edge ordering around the removed edge. Raises ------ NetworkXError If there is not an edge between u and v. See Also -------- remove_edges_from : remove a collection of edges rrz The edge -rN)rrrrrr) r/r#r%rsuccs_vuv_cwuv_ccwvu_cwvu_ccwrs r rPlanarEmbedding.remove_edges$ jjmGjjmGJt$EZ&FJt$EZ&F  1 a   1 a z(.u%(-%z(.u%(-%   ""A3as"BC  sBB C 'CC cUH@nUSSup4X0R;dMX@RU;dM/URX45 MB g)aiRemove all edges specified in ebunch. Parameters ---------- ebunch: list or container of edge tuples Each pair of half-edges between the nodes given in the tuples will be removed from the graph. The nodes can be passed as: - 2-tuples (u, v) half-edges (u, v) and (v, u). - 3-tuples (u, v, k) where k is ignored. See Also -------- remove_edge : remove a single edge Notes ----- Will fail silently if an edge in ebunch is not in the graph. Examples -------- >>> G = nx.path_graph(4) # or DiGraph, MultiGraph, MultiDiGraph, etc >>> ebunch = [(1, 2), (2, 3)] >>> G.remove_edges_from(ebunch) Nrx)rr)r/ebunchrur#r%s r remove_edges_from!PlanarEmbedding.remove_edges_fromsA4ARa5DAJJ1 1 #5  & r c`XR;a6URU(a"[[URU55nOSnURXUS9 X R;a6URU(a"[[URU55nOSnURX!US9 g)aAdds half-edges for (v, w) and (w, v) at some position. This method should only be called if v and w are in different components, or it might break the embedding. This especially means that if `connect_components(v, w)` is called it is not allowed to call `connect_components(w, v)` afterwards. The neighbor orientations in both directions are all set correctly after the first call. Parameters ---------- v : node w : node See Also -------- add_half_edge Nr)rrrr)r/r%rrbs r connect_components"PlanarEmbedding.connect_componentss& ?tzz!}x 1 ./CC 1C( ?tzz!}x 1 ./CC 1C(r cURRU5nU(a[[U55OSnUR XUS9 g)aAdd a half-edge and set end_node as start_node's leftmost neighbor. The new edge is inserted counterclockwise with respect to the current leftmost neighbor, if there is one. Parameters ---------- start_node : node end_node : node See Also -------- add_half_edge connect_components Nr)rrrrr)r/rrrrs r r#PlanarEmbedding.add_half_edge_firsts=  z*16tHUO,4  :LAr cXUSnX#4$)z|Returns the following half-edge left of a face. Parameters ---------- v : node w : node Returns ------- half-edge : tuple rrD)r/r%rnew_nodes r next_face_half_edge#PlanarEmbedding.next_face_half_edge,s71:e${r c<Uc [5nU/nURX45 UnUnXUSnXa:wdXW:waaURU5 URXV5upVXV4U;a[R "S5eURXV45 Xa:waMZXW:waMaU$)a[Returns nodes on the face that belong to the half-edge (v, w). The face that is traversed lies to the right of the half-edge (in an orientation where v is below w). Optionally it is possible to pass a set to which all encountered half edges are added. Before calling this method, this set must not include any half-edges that belong to the face. Parameters ---------- v : node Start node of half-edge. w : node End node of half-edge. mark_half_edges: set, optional Set to which all encountered half-edges are added. Returns ------- face : list A list of nodes that lie on this face. rz&Bad planar embedding. Impossible face.)r addrr8rr)r/r%rmark_half_edges face_nodes prev_nodecur_node incoming_nodes r rPlanarEmbedding.traverse_face;s0  "!eOS QF#  4( my9   h '"&":":9"O I$7**+STT    5 6 my9r cg)zA valid PlanarEmbedding is undirected. All reverse edges are contained, i.e. for every existing half-edge (v, w) the half-edge in the opposite direction (w, v) is also contained. FrDr3s r is_directedPlanarEmbedding.is_directedfsr c>USLa[RRU5$UR5nURR UR5 UR SURR555 [URU]+SURR555 U$)NTc3H# UHupXR54v M g7fr+)r7).0rds r 'PlanarEmbedding.copy..tsF3E41!VVX3Es "c3~# UH3upUR5Hup4XUR54v M M5 g7fr+)itemsr7)rGr#r$r%datadicts r rIrJus90 ,#zz| 8==? #+ $,s;=) r graphviewsgeneric_graph_viewrgraphupdaterqrrLrr_adj)r/as_viewr rs r r7PlanarEmbedding.copyos d?==33D9 9 NN  tzz" F4::3C3C3EFF dnna/0 99??,0  r )r rrr+F)r>r?r@rArBr0rrrrrrrrr r#rr/r2rr8rrCr7rC __classcell__)rs@r rrsWr8  &,'R$:5.9=$ININV80tH:I8'R'B)<B, )V  r rrU) collectionsrnetworkxr__all__ _dispatchablerrrrrr(rFrXrrtrrDr r r[s# =77@%H&HV% & %#&#L%&,  8  8{{|z bjjz r