U 9v f@sddlmZddlZdddgZddZdddZdd d Zd d Zd dZ GdddZ GdddZ ddZ GdddZ GdddejZdS)) defaultdictNcheck_planarity is_planarPlanarEmbeddingcCst|dddS)a$Returns 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)GrA/tmp/pip-unpacked-wheel-_lngutwb/networkx/algorithms/planarity.pyrsFcCs:t|}|}|dkr.|r(dt|fSdSnd|fSdS)adCheck 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 NFFNT) LRPlanarity lr_planarityget_counterexamplerrplanarity_state embeddingrrr r(s> cCs:t|}|}|dkr.|r(dt|fSdSnd|fSdS)z-Recursive version of :meth:`check_planarity`.NFr T)r lr_planarity_recursiveget_counterexample_recursiverrrr check_planarity_recursivess rcCs|t|}t|dr tdt}|D]J}t||}|D]4}|||t|dr@||||||q@q,|S)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_edgerZsubgraphuZnbrsvrrr r s       r cCs|t|}t|dr tdt}|D]J}t||}|D]4}|||t|dr@||||||q@q,|S)z0Recursive version of :meth:`get_counterexample`.rr)rrrrrrrrrrr rs       rc@s2eZdZdZd ddZddZddZd d ZdS) 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. NcCs||_||_dSNlowhigh)selfr!r"rrr __init__szInterval.__init__cCs|jdko|jdkS)zCheck if the interval is emptyNr r#rrr emptyszInterval.emptycCst|j|jS)zReturns a copy of this interval)rr!r"r%rrr copysz Interval.copycCs | o|j|j|j|kS)z0Returns True if interval I conflicts with edge b)r&lowptr")r#brrrr conflictings zInterval.conflicting)NN)__name__ __module__ __qualname____doc__r$r&r'r*rrrr rs  rc@s2eZdZdZeefddZddZddZdS) 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. cCs||_||_dSrleftright)r#r1r2rrr r$szConflictPair.__init__cCs|j}|j|_||_dS)zSwap left and right intervalsNr0)r#temprrr swapszConflictPair.swapcCsN|jr|j|jjS|jr0|j|jjSt|j|jj|j|jjS)z.Returns the lowest lowpoint of a conflict pair)r1r&r(r2r!min)r#rrrr lowests   zConflictPair.lowestN)r+r,r-r.rr$r4r6rrrr r/sr/cCs|sdS|dS)z(Returns the element on top of the stack.Nr)lrrr top_of_stacksr9c@seZdZdZdddddddd d d d d ddddddgZddZddZddZddZddZ ddZ d d!Z d"d#Z d$d%Z d&d'Zd(d)Zd*d+Zd,d-Zd.S)/r z5A class to maintain the state during planarity check.rrootsheightr(lowpt2 nesting_depth parent_edgeDGadjs ordered_adjsrefsideS stack_bottom lowpt_edgeleft_ref right_refrcCst|_|j|j|jD]*}|d|dkr|j|d|dqg|_tdd|_ i|_ i|_ i|_ tdd|_ t|_|j|ji|_i|_tdd|_tdd|_g|_i|_i|_i|_i|_t|_dS)NrcSsdSrrrrrr  z&LRPlanarity.__init__..cSsdSrrrrrr rJ'rKcSsdSrrrrrr rJ0rKcSsdS)NrIrrrrr rJ1rK)rrradd_nodes_fromnodesedgesrr:rr;r(r<r=r>DiGraphr?r@rArBrCrDrErFrGrHrr)r#rerrr r$s.   zLRPlanarity.__init__csjdkr.jdjdkr.dSjD]tjj<q4jD]2jdkrTdj<jqTd_d_ d_j D]&t j fdddj <qjD] sdSqd_d_d_d_d_j jD] }|j|j|<q jj jj D]Rt j fd ddj <d}j D]}j|||}qvqBd_ d_d_jD]qd_d_d_ d_d_d_jS) zExecute the LR planarity test. Returns ------- embedding : dict If the graph is planar an embedding is returned. Otherwise None. Nrcsj|fSrr=xr#rrr rJ]rKz*LRPlanarity.lr_planarity..keycsj|fSrrTrUrWrr rJqrK)rordersizerr@r;r:appenddfs_orientationr<r?sortedrA dfs_testingr(rDrErFrNsignr=rrLrMadd_half_edge_cwrB dfs_embeddingr>rGrHrCr#rPZ previous_nodewrrWr r =sb*              zLRPlanarity.lr_planaritycsfjdkr.jdjdkr.dSjD]2jdkr4dj<jq4d_jD]&tjfdddj <qtjD] sdSqjj D]} |j |j |<qjjjjD]Ptjfd ddj <d}j D]}j|||}q*qjD]qNjS) z*Recursive version of :meth:`lr_planarity`.rQrRrSNrcsj|fSrrTrUrWrr rJrKz4LRPlanarity.lr_planarity_recursive..rXcsj|fSrrTrUrWrr rJrK)rrZr[r;r:r\dfs_orientation_recursiver?r^rAdfs_testing_recursiverNsign_recursiver=rrLrMradfs_embedding_recursivercrrWr rs>*             z"LRPlanarity.lr_planarity_recursivecCs|g}tdd}tdd}|r|}|j|}|j|||dD]}||f}||s$||f|jjks||f|jjkr||d7<qL|j|||j||j|<|j||j |<|j|dkr||j|<|j|d|j|<| || |d||<qn|j||j|<d|j||j |<|j ||j|kr`|j |d7<|dk r|j||j|krt |j||j ||j |<|j||j|<nP|j||j|krt |j ||j||j |<nt |j ||j ||j |<||d7<qLqdS)z=Orient the graph by DFS, compute lowpoints and nesting order.cSsdSNrrrrrr rJrKz-LRPlanarity.dfs_orientation..cSsdSNFrrrrr rJrKNrITrQ) rpopr>r@r?rNrr;r(r<r\r=r5)r#r dfs_stackind skip_initrPrdvwrrr r]sD         zLRPlanarity.dfs_orientationcCs|j|}|j|D]z}||f|jjks||f|jjkrrr?rNrr;r(r<rer=r5)r#rrPrdrorrr res.    z%LRPlanarity.dfs_orientation_recursivec CsJ|g}tdd}tdd}|rF|}|j|}d}|j|||dD]}||f}||st|j|j|<||j|kr||||d||<d}q.n"||j|<|jt t ||d|j ||j |kr||j|dkr|j||j|<n| ||sdS||d 7<qP|s|dk r||qdS) zTest for LR partition.cSsdSrirrrrr rJrKz)LRPlanarity.dfs_testing..cSsdSrjrrrrr rJrKFNTr2rrI)rrkr>rAr9rDrEr\rFr/rr(r;add_constraintsremove_back_edges) r#rrlrmrnrPZ skip_finalrdeirrr r_s:       zLRPlanarity.dfs_testingcCs|j|}|j|D]}||f}t|j|j|<||j|krP||srdSn"||j|<|jtt ||d|j ||j |kr||j|dkr|j||j|<q| ||sdSq|dk r| |dS)z)Recursive version of :meth:`dfs_testing`.FrprNT)r>rAr9rDrErfrFr\r/rr(r;rqrr)r#rrPrdrsrrr rfBs"     z!LRPlanarity.dfs_testing_recursivecCst}|j}|js"||js0dS|j|jj|j|kr|jr`|j |_n|jj |j |jj<|jj|j_n|j ||j |jj<t |j|j|krqqt |jj||st |jj||rp|j}|j||r||j||r dS|jj |j |jj<|jjdk r6|jj|j_|jrP|j |_n|jj |j |jj<|jj|j_q|jr|js|j|dS)NFT)r/rDrkr1r&r4r(r2r!r'r"rBrFr9rEr*r\)r#rsrPPQrrr rq]sF        zLRPlanarity.add_constraintscCs|d}|jrNt|j||j|krN|j}|jjdk rd|j|jj<q|jrT|j}|jjdk r|jjd|kr|j |jj|j_q`|jjdkr|jjdk r|j j|j |jj<d|j|jj<d|j_|j jdk r|j jd|kr|j |j j|j _q|j jdkrH|j jdk rH|jj|j |j j<d|j|j j<d|j _|j ||j ||j|krt|jjj}t|jj j}|dk r|dks|j ||j |kr||j |<n ||j |<dS)Nrr7rI) rDr9r6r;rkr1r!rCr"rBr2r\r()r#rPrrtZhlhrrrr rrs4      * zLRPlanarity.remove_back_edgescCs|g}tdd}|r|}|j|||dD]}||d7<||f}||j|kr|j||||j|<||j|<||||qq4|j |dkr|j |||j|q4|j |||j|||j|<q4qdS)zCompletes the embedding.cSsdSrirrrrr rJrKz+LRPlanarity.dfs_embedding..NrI) rrkrAr>radd_half_edge_firstrGrHr\rCraadd_half_edge_ccw)r#rrlrmrdrsrrr rbs$     zLRPlanarity.dfs_embeddingcCs|j|D]}||f}||j|krR|j||||j|<||j|<||q |j|dkrx|j|||j|q |j |||j|||j|<q dS)z+Recursive version of :meth:`dfs_embedding`.rIN) rAr>rrwrGrHrhrCrarx)r#rrdrsrrr rhs   z#LRPlanarity.dfs_embedding_recursivecCs|g}tdd}|r~|}|j|dk r`||||j||j|||<d|j|<q|j||j||9<q|j|S)z:Resolve the relative side of an edge to the absolute side.cSsdSrrrrrr rJrKz"LRPlanarity.sign..N)rrkrBr\rC)r#rPrlZold_refrrr r`s   zLRPlanarity.signcCsB|j|dk r8|j|||j||j|<d|j|<|j|S)z"Recursive version of :meth:`sign`.N)rBrCrg)r#rPrrr rgs  zLRPlanarity.sign_recursiveN)r+r,r-r. __slots__r$r rr]rer_rfrqrrrbrhr`rgrrrr r sB(O/5!1,'r c@sjeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ dddZ ddZdS)ra 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. * A node with non zero degree must have a node attribute 'first_nbr'. As long as a PlanarEmbedding is invalid only the following methods should be called: * :meth:`add_half_edge_ccw` * :meth:`add_half_edge_cw` * :meth:`connect_components` * :meth:`add_half_edge_first` 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_ccw` 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 orientated 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_cw(0, 1, None) >>> G.add_half_edge_cw(0, 2, 1) >>> G.add_half_edge_cw(0, 3, 2) >>> G.add_half_edge_cw(1, 0, None) >>> G.add_half_edge_cw(2, 0, None) >>> G.add_half_edge_cw(3, 0, None) 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_ccw(0, 1, None) >>> G.add_half_edge_ccw(0, 3, 1) >>> G.add_half_edge_ccw(0, 2, 3) >>> G.add_half_edge_ccw(1, 0, None) >>> G.add_half_edge_ccw(2, 0, None) >>> G.add_half_edge_ccw(3, 0, None) After creating a graph, it is possible to validate that the PlanarEmbedding object is correct: >>> G.check_structure() cCs$i}|D]}t||||<q|S)aConverts 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#rrrrr get_dataXszPlanarEmbedding.get_datacCs,|D]"}t||D]}|||qqdS)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 N)reversedrw)r#datarrdrrr set_datakszPlanarEmbedding.set_dataccs\t||dkrdS|j|d}|V|||d}||krX|V|||d}q8dS)zGenerator for the neighbors of v in clockwise order. Parameters ---------- v : node Yields ------ node rN first_nbrcw)lenrM)r#r start_nodeZ current_noderrr rzs z"PlanarEmbedding.neighbors_cw_orderc CsB|D]}zt||}Wn8tk rR}zd|}t||W5d}~XYnXt||}||krvd}t|||D]}|||s~d}t|q~qt}t|D]}t|dkrqt|} d} d} |D]>}||D].}| d7} ||f|kr| d7} ||||qq| d} | | | dkrd}t|qdS) awRuns 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. * A node with a degree larger than 0 has a node attribute 'first_nbr'. 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.rIrrQz7Bad embedding. The graph does not match Euler's formula) setrzKeyErrorrrZhas_edgeZconnected_componentsr traverse_face) r#rZ sorted_nbrserrmsgZ unsorted_nbrsrdZcounted_half_edges componentZ num_nodesZnum_half_edgesZ num_facesZ num_edgesrrr check_structures>       zPlanarEmbedding.check_structurecCs|dkrD|||||||d<||||d<||j|d<nB|||d}||||||j|ddkr||j|d<dS)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_cw connect_components add_half_edge_first Nrccwr)rrMraget)r#rend_nodereference_neighborZ ccw_referencerrr rxs z!PlanarEmbedding.add_half_edge_ccwcCs||||dkrF||||d<||||d<||j|d<dS|||kr\td|||d}||||d<||||d<||||d<||||d<dS)a~Adds 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_ccw connect_components add_half_edge_first Nrrrz2Cannot add edge. Reference neighbor does not exist)rrMrr)r#rrrZ cw_referencerrr ras  z PlanarEmbedding.add_half_edge_cwcCs||||||dS)atAdds 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_ccw add_half_edge_cw add_half_edge_first N)rw)r#rrdrrr connect_components)s z"PlanarEmbedding.connect_componentscCs<||kr&d|j|kr&|j|d}nd}||||dS)aThe added half-edge is inserted at the first position in the order. Parameters ---------- start_node : node end_node : node See Also -------- add_half_edge_ccw add_half_edge_cw connect_components rN)rMrx)r#rr referencerrr rwAsz#PlanarEmbedding.add_half_edge_firstcCs|||d}||fS)zReturns the following half-edge left of a face. Parameters ---------- v : node w : node Returns ------- half-edge : tuple rr)r#rrdZnew_noderrr next_face_half_edgeUs z#PlanarEmbedding.next_face_half_edgeNcCs|dkrt}|g}|||f|}|}|||d}||ksJ||kr|||||\}}||f|krztd|||fq:|S)aReturns 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. Nrz&Bad planar embedding. Impossible face.)raddr\rrr)r#rrdZmark_half_edgesZ face_nodesZ prev_nodeZcur_nodeZ incoming_noderrr rds   zPlanarEmbedding.traverse_facecCsdS)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. Frr%rrr is_directedszPlanarEmbedding.is_directed)N)r+r,r-r.r{r~rzrrxrarrwrrrrrrr rs\;)0 +)F)F) collectionsrZnetworkxr__all__rrrr rrr/r9r rOrrrrr s   K &