layout                 package:RBGL                 R Documentation

_L_a_y_o_u_t _a_n _u_n_d_i_r_e_c_t_e_d _g_r_a_p_h _i_n _2_D

_D_e_s_c_r_i_p_t_i_o_n:

     Layout an undirected graph in 2D

_U_s_a_g_e:

     circleLayout(g, radius=1)
     kamadaKawaiSpringLayout( g, edge_or_side=1, es_length=1 )
     fruchtermanReingoldForceDirectedLayout(g, width=1, height=1)
     randomGraphLayout(g, minX=0, maxX=1, minY=0, maxY=1)

_A_r_g_u_m_e_n_t_s:

       g: an instance of the 'graph' class with 'edgemode' undirected

  radius: radius of a regular n-polygon

edge_or_side: boolean indicating the length is for an edge or for a 
          side, default is for an edge 

es_length: the length of an edge or a side for layout 

   width: the width of the dislay area, all x coordinates fall in
          [-width/2, width/2]

  height: the height of the display area, all y coordinates fall in
          [-height/2, height/2]

    minX: minimum x coordinate

    maxX: maximum x coordinate

    minY: minimum y coordinate

    maxY: maximum y coordinate

_D_e_t_a_i_l_s:

     If you want to simply draw a graph, you should consider using
     package  _Rgraphviz_.  The layout options in package _Rgraphviz_:
     'neato', 'circo' and 'fdp', correspond to
     'kamadaKawaiSpringLayout',  'circleLayout' and
     'fruchtermanReingoldForceDirectedLayout',  respectively. 

     Function 'circleLayout' layouts the graph with the vertices at the
     points  of a regular n-polygon.  The distance from the center of
     the polygon to each  point is determined by the 'radius'
     parameter.

     Function 'kamadaKawaiSpringLayout' provides Kamada-Kawai spring
     layout for  connected, undirected graphs.  User provides either
     the unit length e of an  edge in the layout or the length of a
     side s of the display area.

     Function 'randomGraphLayout' places the points of the graph at
     random locations.

     Function 'fruchtermanReingoldForceDirectedLayout' performs layout
     of  unweighted, undirected graphs.  It's a force-directed
     algorithm.  The BGL  implementation doesn't handle disconnected
     graphs very well, since it doesn't explicitly give each connected
     component a region proportional to its size. 

     See documentation on this function in Boost Graph Library for more
     details.

_V_a_l_u_e:

     A (2 x n) matrix, where n is the number of nodes in the graph,
     each column gives the (x, y)-coordinates for the corresponding
     node.

_A_u_t_h_o_r(_s):

     Li Long <li.long@isb-sib.ch>

_R_e_f_e_r_e_n_c_e_s:

     Boost Graph Library ( www.boost.org/libs/graph/doc/index.html )

     The Boost Graph Library: User Guide and Reference Manual; by
     Jeremy G. Siek, Lie-Quan Lee, and Andrew Lumsdaine;
     (Addison-Wesley, Pearson Education Inc., 2002), xxiv+321pp. ISBN
     0-201-72914-8

_S_e_e _A_l_s_o:

     'layoutGraph'

_E_x_a_m_p_l_e_s:

     con <- file(system.file("XML/conn.gxl",package="RBGL"), open="r")
     coex <- fromGXL(con)
     close(con)

     coex <- ugraph(coex)

     circleLayout(coex)

     kamadaKawaiSpringLayout(coex)

     randomGraphLayout(coex)

     fruchtermanReingoldForceDirectedLayout(coex, 10, 10)

