U tds@sdZddlmZmZmZddlmZddlmZddl m Z dZ GdddZ d)d d Z d d Zd*ddZddZddZddddddddddddddd d d d!d"d#d#d#d$d$d%d%d&d'd(Zd S)+zo Layout-related code in the igraph library. This package contains the implementation of the L{Layout} object. )sincospi) GraphBase) BoundingBox RunningMean)Layout_layout _layout_auto_layout_sugiyama_layout_method_wrapper_3d_version_for_layout_mappingc@seZdZdZd6ddZddZddZd d Zd d Zd dZ ddZ e ddZ e ddZ ddZddZd7ddZddZdd Zd8d%d&Zd'd(Zd)d*Zd9d+d,Zd:d-d.Zd/d0Zd1d2Zd;d4d5ZdS)>> layout = Layout([(0, 1), (0, 2)]) >>> coords = layout[1] >>> print(coords) [0, 2] >>> coords = (0, 3) >>> print(layout[1]) [0, 2] >>> layout[1] = coords >>> print(layout[1]) [0, 3] NcCs|dk rdd|D|_ng|_|dkrPt|jdkr>d|_qt|jd|_n6t||_|jD]$}t||jkr`tdd|jq`dS)aConstructor. @param coords: the coordinates to be stored in the layout. @param dim: the number of dimensions. If C{None}, the number of dimensions is determined automatically from the length of the first item of the coordinate list. If there are no entries in the coordinate list, the default will be 2. Generally, this should be given if the length of the coordinate list is zero, otherwise it should be left as is. NcSsg|] }t|qS)list.0ZcoordrrF/home/sam/Atlas/atlas_env/lib/python3.8/site-packages/igraph/layout.py Isz#Layout.__init__..rz!all items in the coordinate list zmust have a length of %d)_coordslen_dimint ValueError)selfcoordsdimrowrrr__init__=s   zLayout.__init__cCs t|jSN)rrrrrr__len__[szLayout.__len__cCs |j|Sr!rridxrrr __getitem__^szLayout.__getitem__cCs.t||jkrtd|jt||j|<dS)Nz#assigned item must have %d elements)rrrrr)rr&valuerrr __setitem__aszLayout.__setitem__cCs |j|=dSr!r$r%rrr __delitem__fszLayout.__delitem__cCs||j|jSr!) __class__rrr"rrr__copy__iszLayout.__copy__cCsZ|js d}n"t|jdkr d}ndt|j}|jdkr>d}n d|j}d|jj||fS)Nz no verticesz1 vertexz %d verticesz 1 dimensionz %d dimensionsz<%s with %s and %s>)rrrr+__name__)rZ vertex_countZ dim_countrrr__repr__ls  zLayout.__repr__cCs|jS)z Returns the number of dimensions)rr"rrrr}sz Layout.dimcCsdd|jDS)z"The coordinates as a list of listscSsg|]}|ddqSr!rrrrrrrsz!Layout.coords..r$r"rrrrsz Layout.coordscCs@t||jkrtd|j|jdd|d|jDdS)z!Appends a new point to the layoutz#appended item must have %d elementscSsg|] }t|qSrfloatrrrrrsz!Layout.append..rN)rrrrappend)rr(rrrr3sz Layout.appendcCsJt|tr|g}ndd|D}|D] }|jD]}||d9<q.q$dS)zzMirrors the layout along the given dimension(s) @param dim: the list of dimensions or a single dimension cSsg|] }t|qSr)r)rxrrrrsz!Layout.mirror..N) isinstancerr)rrZ current_dimrrrrmirrors   z Layout.mirrorrr-c Kst|ddg|j}t||jkr4td|j|td}t|t|}}t|j D]b\} } | |||| |||} } || || ||| |<|| || ||| |<q\dS)aRotates the layout by the given degrees on the plane defined by the given two dimensions. @param angle: the angle of the rotation, specified in degrees. @param dim1: the first axis of the plane of the rotation. @param dim2: the second axis of the plane of the rotation. @keyword origin: the origin of the rotation. If not specified, the origin will be the origin of the coordinate system. originorigin must have %d dimensionsf@N) rgetrrrrrr enumerater) rZangleZdim1Zdim2kwdsr8ZradianZ cos_alphaZ sin_alphar&rr4yrrrrotates  "z Layout.rotatecst|ddg|jt|jkr4td|j|dp@|tttfrVgtdkrltdn@tdkrtdtkstdtkr|j9ndt|jkrtd|jt |j D]*\}fd d t |jD|j |<qd S) aScales the layout. Scaling parameters can be provided either through the C{scale} keyword argument or through plain unnamed arguments. If a single integer or float is given, it is interpreted as a uniform multiplier to be applied on all dimensions. If it is a list or tuple, its length must be equal to the number of dimensions in the layout, and each element must be an integer or float describing the scaling coefficient in one of the dimensions. @keyword scale: scaling coefficients (integer, float, list or tuple) @keyword origin: the origin of scaling (this point will stay in place). Optional, defaults to the origin of the coordinate system being used. r8r9r:scalerzscaling factor must be givenr-z)scaling factor list must have %d elementscs,g|]$}||||qSrrrdr8rZscalingrrrsz Layout.scale..N) rr<rrrr6rr2typer=rrangerargsr>r&rrDrrAs$     z Layout.scalecs|dp |tdkr$tdn4tdkrXtdtkrXtdtkrXdt|jkrttd|jt|jD](\}fddt |jD|j|<q~dS) aTranslates the layout. The translation vector can be provided either through the C{v} keyword argument or through plain unnamed arguments. If unnamed arguments are used, the vector can be supplied as a single list (or tuple) or just as a series of arguments. In all cases, the translation vector must have the same number of dimensions as the layout. @keyword v: the translation vector vrz translation vector must be givenr-z*translation vector must have %d dimensionscsg|]}||qSrrrBrrIrrrsz$Layout.translate..N) r<rrrErr2rr=rrFrGrrJr translates   ,zLayout.translatedPr9?c Cs|jdkrtd|}||kr,|d7}q|dkrF|d8}|d8}q,|dkr`|d7}|d7}qF|||j}|td9}|td9}|||j}t|jD]P\}\} } | |j||} | |j ||} t | | t |  | g|j|<qdS)amConverts a planar layout to a radial one This method applies only to 2D layouts. The X coordinate of the layout is transformed to an angle, with min(x) corresponding to the parameter called I{min_angle} and max(y) corresponding to I{max_angle}. Angles are given in degrees, zero degree corresponds to the direction pointing upwards. The Y coordinate is interpreted as a radius, with min(y) belonging to the minimum and max(y) to the maximum radius given in the arguments. This is not a fully generic polar coordinate transformation, but it is fairly useful in creating radial tree layouts from ordinary top-down ones (that's why the Y coordinate belongs to the radius). It can also be used in conjunction with the Fruchterman-Reingold layout algorithm via its I{miny} and I{maxy} parameters (see L{Graph.layout_fruchterman_reingold()}) to produce radial layouts where the radius belongs to some property of the vertices. @param min_angle: the angle corresponding to the minimum X value @param max_angle: the angle corresponding to the maximum X value @param min_radius: the radius corresponding to the minimum Y value @param max_radius: the radius corresponding to the maximum Y value rzimplemented only for 2D layoutsihrr;N) r TypeError bounding_boxwidthrheightr=rlefttoprr) rZ min_angleZ max_angleZ min_radiusZ max_radiusbboxZratio_xZratio_yr&r4r?alphaZradiusrrr to_radials&      zLayout.to_radialcsfdd|jD|_dS)aPerforms an arbitrary transformation on the layout Additional positional and keyword arguments are passed intact to the given function. @param function: a function which receives the coordinates as a tuple and returns the transformed tuple. cs$g|]}tt|fqSr)rtupler0rHfunctionr>rrr%sz$Layout.transform..Nr$)rrZrHr>rrYr transforms zLayout.transformcCsPddt|jD}|jD]&}t|jD]}||||q(qdd|DS)zReturns the centroid of the layout. The centroid of the layout is the arithmetic mean of the points in the layout. @return: the centroid as a list of floatscSsg|] }tqSrr)r_rrrr0sz#Layout.centroid..cSsg|] }|jqSr)Zmean)rZrmrrrr4s)rFrradd)rcentroidrrrrrr^)s  zLayout.centroidcsh|jstdgg}}t|jD]<fdd|jD}|t|||t||q"||fS)aRReturns the boundaries of the layout. The boundaries are the minimum and maximum coordinates along all dimensions. @param border: this value gets subtracted from the minimum bounds and gets added to the maximum bounds before returning the coordinates of the box. Defaults to zero. @return: the minimum and maximum coordinates along all dimensions, in a tuple containing two lists, one for the minimum coordinates, the other one for the maximum. @raises ValueError: if the layout contains no layout items zlayout contains no layout itemscsg|] }|qSrrr0rrrrIsz%Layout.boundaries..)rrrFrr3minmax)rborderminsmaxscolrr_r boundaries6s zLayout.boundariescCs`|jdkrtdz&||\\}}\}}t||||WStk rZtddddYSXdS)aPReturns the bounding box of the layout. The bounding box of the layout is the smallest box enclosing all the points in the layout. @param border: this value gets subtracted from the minimum bounds and gets added to the maximum bounds before returning the coordinates of the box. Defaults to zero. @return: the coordinates of the lower left and the upper right corner of the box. "Lower left" means the minimum coordinates and "upper right" means the maximum. These are encapsulated in a L{BoundingBox} object. rz.Layout.boundary_box() supports 2D layouts onlyrN)rrrfr)rrbZx0Zy0x1y1rrrrPNs zLayout.bounding_boxcs|dp |tdkr(dg|jn4tdkr\tdtkr\tdtkr\dt|jkrxtd|j|fddt|jD}| |dS) aCenters the layout around the given point. The point itself can be supplied as multiple unnamed arguments, as a simple unnamed list or as a keyword argument. This operation moves the centroid of the layout to the given point. If no point is supplied, defaults to the origin of the coordinate system. @keyword p: the point where the centroid of the layout will be after the operation.prr9r-z'the given point must have %d dimensionscsg|]}||qSrrrBcenterr^rrrvsz!Layout.center..N) r<rrrErr2rr^rFrK)rrHr>Zvecrrjrrkds  ,z Layout.centercCs|S)z$Creates an exact copy of the layout.)r,r"rrrcopyysz Layout.copyTcCst|tr8|jdkrtd|j|jg|j|jg}}nt||jkr^dg|jt |}}nt|d|jkrt |d|jt ||jd}}t |jD].}||||kr||||||<||<qddt ||D}z| \}}Wn0t k r$dg|jdg|j}}YnXddt ||D} t| D]<\}} | dkrBd| |<||d 8<||d 7<qBd dt | |D} |rt| } | g|j} g} t |jD]H}||| || |d }|||| |||8}| |q|j| |j| dS) aFits the layout into the given bounding box. The layout will be modified in-place. @param bbox: the bounding box in which to fit the layout. If the dimension of the layout is d, it can either be a d-tuple (defining the sizes of the box), a 2d-tuple (defining the coordinates of the top left and the bottom right point of the box), or a L{BoundingBox} object (for 2D layouts only). @param keep_aspect_ratio: whether to keep the aspect ratio of the current layout. If C{False}, the layout will be rescaled to fit exactly into the bounding box. If C{True}, the original aspect ratio of the layout will be kept and it will be centered within the bounding box. rz'bounding boxes work for 2D layouts onlyr9rNcSsg|]\}}||qSrrrZmin_valZmax_valrrrrsz#Layout.fit_into..cSsg|]\}}||qSrrrmrrrrsr-cSsg|]\}}t||qSrr1)rZ current_sizeZ target_sizerrrrsg@)r6rrrOrSrTrQrRrrrFziprfrr=r`r3rArK)rrUZkeep_aspect_ratioZcornerZ target_sizesZopposite_cornerircrdsizessizeratiosZ min_ratioZ translationsZtransrrrfit_into}sJ  &    zLayout.fit_into)NN)rr-)rLrMr9rN)r)r)T)r. __module__ __qualname____doc__r r#r'r)r*r,r/propertyrrr3r7r@rArKrWr[r^rfrPrkrlrsrrrrr s2    % /   r NcOsddlm}|dkr|d}t|dr,|}nd|}|dddkrZd|d <|dd}n$|d dd kr~d|d <|dd }t|j|j|}t|dstd ||f||}t|t st |}|S) a Returns the layout of the graph according to a layout algorithm. Parameters and keyword arguments not specified here are passed to the layout algorithm directly. See the documentation of the layout algorithms for the explanation of these parameters. Registered layout names understood by this method are: - C{auto}, C{automatic}: automatic layout (see L{Graph.layout_auto}) - C{bipartite}: bipartite layout (see L{GraphBase.layout_bipartite}) - C{circle}, C{circular}: circular layout (see L{GraphBase.layout_circle}) - C{dh}, C{davidson_harel}: Davidson-Harel layout (see L{GraphBase.layout_davidson_harel}) - C{drl}: DrL layout for large graphs (see L{GraphBase.layout_drl}) - C{drl_3d}: 3D DrL layout for large graphs (see L{GraphBase.layout_drl}) - C{fr}, C{fruchterman_reingold}: Fruchterman-Reingold layout (see L{GraphBase.layout_fruchterman_reingold}). - C{fr_3d}, C{fr3d}, C{fruchterman_reingold_3d}: 3D Fruchterman- Reingold layout (see L{GraphBase.layout_fruchterman_reingold}). - C{grid}: regular grid layout in 2D (see L{GraphBase.layout_grid}) - C{grid_3d}: regular grid layout in 3D (see L{GraphBase.layout_grid}) - C{graphopt}: the graphopt algorithm (see L{GraphBase.layout_graphopt}) - C{kk}, C{kamada_kawai}: Kamada-Kawai layout (see L{GraphBase.layout_kamada_kawai}) - C{kk_3d}, C{kk3d}, C{kamada_kawai_3d}: 3D Kamada-Kawai layout (see L{GraphBase.layout_kamada_kawai}) - C{lgl}, C{large}, C{large_graph}: Large Graph Layout (see L{GraphBase.layout_lgl}) - C{mds}: multidimensional scaling layout (see L{GraphBase.layout_mds}) - C{random}: random layout (see L{GraphBase.layout_random}) - C{random_3d}: random 3D layout (see L{GraphBase.layout_random}) - C{rt}, C{tree}, C{reingold_tilford}: Reingold-Tilford tree layout (see L{GraphBase.layout_reingold_tilford}) - C{rt_circular}, C{reingold_tilford_circular}: circular Reingold-Tilford tree layout (see L{GraphBase.layout_reingold_tilford_circular}) - C{sphere}, C{spherical}, C{circle_3d}, C{circular_3d}: spherical layout (see L{GraphBase.layout_circle}) - C{star}: star layout (see L{GraphBase.layout_star}) - C{sugiyama}: Sugiyama layout (see L{Graph.layout_sugiyama}) @param layout: the layout to use. This can be one of the registered layout names or a callable which returns either a L{Layout} object or a list of lists containing the coordinates. If C{None}, uses the value of the C{plotting.layout} configuration key. @return: a L{Layout} object. r)configNzplotting.layout__call__Z_3drZ3dzlayout method must be callable) Zigraphrxhasattrlowergetattrr+rrr6r )graphlayoutrHr>rxmethodrrrr s&I     r cOsd|krb|d}t|tr"|St|ttfr8t|St|drPt|||S|j|f||S|dd}|}d|krd|kr|dkrd|krttt |j d|j d|j dSttt |j d|j dS| d kr| rd }n| d krd }nd }|j|f||S)aChooses and runs a suitable layout function based on simple topological properties of the graph. This function tries to choose an appropriate layout function for the graph using the following rules: 1. If the graph has an attribute called C{layout}, it will be used. It may either be a L{Layout} instance, a list of coordinate pairs, the name of a layout function, or a callable function which generates the layout when called with the graph as a parameter. 2. Otherwise, if the graph has vertex attributes called C{x} and C{y}, these will be used as coordinates in the layout. When a 3D layout is requested (by setting C{dim} to 3), a vertex attribute named C{z} will also be needed. 3. Otherwise, if the graph is connected and has at most 100 vertices, the Kamada-Kawai layout will be used (see L{GraphBase.layout_kamada_kawai()}). 4. Otherwise, if the graph has at most 1000 vertices, the Fruchterman-Reingold layout will be used (see L{GraphBase.layout_fruchterman_reingold()}). 5. If everything else above failed, the DrL layout algorithm will be used (see L{GraphBase.layout_drl()}). All the arguments of this function except C{dim} are passed on to the chosen layout function (in case we have to call some layout function). @keyword dim: specifies whether we would like to obtain a 2D or a 3D layout. @return: a L{Layout} object. rryrrr4r?r{zrLkkifrdrl) attributesr6r rrXr}rr<Zvertex_attributesrnvsZvcountZ is_connected)rrHr>rrZvattrsalgorrrr s*%    &r r-rLFc CsP|stt|||||||St|||||||\}}} | |jd<t||fS)a Places the vertices using a layered Sugiyama layout. This is a layered layout that is most suitable for directed acyclic graphs, although it works on undirected or cyclic graphs as well. Each vertex is assigned to a layer and each layer is placed on a horizontal line. Vertices within the same layer are then permuted using the barycenter heuristic that tries to minimize edge crossings. Dummy vertices will be added on edges that span more than one layer. The returned layout therefore contains more rows than the number of nodes in the original graph; the extra rows correspond to the dummy vertices. @param layers: a vector specifying a non-negative integer layer index for each vertex, or the name of a numeric vertex attribute that contains the layer indices. If C{None}, a layering will be determined automatically. For undirected graphs, a spanning tree will be extracted and vertices will be assigned to layers using a breadth first search from the node with the largest degree. For directed graphs, cycles are broken by reversing the direction of edges in an approximate feedback arc set using the heuristic of Eades, Lin and Smyth, and then using longest path layering to place the vertices in layers. @param weights: edge weights to be used. Can be a sequence or iterable or even an edge attribute name. @param hgap: minimum horizontal gap between vertices in the same layer. @param vgap: vertical gap between layers. The layer index will be multiplied by I{vgap} to obtain the Y coordinate. @param maxiter: maximum number of iterations to take in the crossing reduction step. Increase this if you feel that you are getting too many edge crossings. @param return_extended_graph: specifies that the extended graph with the added dummy vertices should also be returned. When this is C{True}, the result will be a tuple containing the layout and the extended graph. The first |V| nodes of the extended graph will correspond to the nodes of the original graph, the remaining ones are dummy nodes. Plotting the extended graph with the returned layout and hidden dummy nodes will produce a layout that is similar to the original graph, but with the added edge bends. The extended graph also contains an edge attribute called C{_original_eid} which specifies the ID of the edge in the original graph from which the edge of the extended graph was created. @return: the calculated layout, which may (and usually will) have more rows than the number of vertices; the remaining rows correspond to the dummy nodes introduced in the layering step. When C{return_extended_graph} is C{True}, it will also contain the extended graph. @newfield ref: Reference @ref: K Sugiyama, S Tagawa, M Toda: Methods for visual understanding of hierarchical system structures. IEEE Systems, Man and Cybernetics 11(2):109-125, 1981. @ref: P Eades, X Lin and WF Smyth: A fast effective heuristic for the feedback arc set problem. Information Processing Letters 47:319-323, 1993. Z _original_eid)r rr es) rZlayersweightsZhgapZvgapmaxiterZreturn_extended_graphrZ extd_graphZextd_to_orig_eidsrrrr ]s.=  r cs fdd}j|_j|_|S)zWraps an existing layout method to ensure that it returns a Layout instead of a list of lists. @param func: the method to wrap. Must be a method of the Graph object. @return: a new method cs ||}t|tst|}|Sr!)r6r )rHr>rfuncrrresults  z&_layout_method_wrapper..resultr.rvrrrrrr s r cs.fdd}dj|_djjf|_|S)a#Creates an alias for the 3D version of the given layout algoritm. This function is a decorator that creates a method which calls I{func} after attaching C{dim=3} to the list of keyword arguments. @param func: must be a method of the Graph object. @return: a new method csd|d<||S)Nr{rr)rHr>rrrrsz_3d_version_for..resultz%s_3dz/Alias for L{%s()} with dim=3. @see: Graph.%s()rrrrrrs  rZ layout_autoZlayout_bipartiteZ layout_circleZlayout_davidson_harelZ layout_drlZlayout_fruchterman_reingoldZlayout_graphoptZ layout_gridZlayout_kamada_kawaiZ layout_lglZ layout_mdsZ layout_randomZlayout_reingold_tilfordZ layout_reingold_tilford_circularZ layout_sphereZ layout_starZlayout_sugiyama)autoZ automaticZ bipartitecircleZcircularZdavidson_harelZdhrrZfruchterman_reingoldZgraphoptgridrZ kamada_kawaiZlglZlargeZ large_graphZmdsrandomrttreeZreingold_tilfordZ rt_circularZreingold_tilford_circularZsphereZ sphericalstarZsugiyama)N)NNr-r-rLF)rvmathrrrZigraph._igraphrZigraph.drawing.utilsrZigraph.statisticsr__all__r r r r r rrrrrrsb     `F K