layoutGraph            package:Rgraphviz            R Documentation

_A _f_u_n_c_t_i_o_n _t_o _c_o_m_p_u_t_e _l_a_y_o_u_t_s _o_f  _g_r_a_p_h _o_b_j_e_c_t_s

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

     This is a wrapper to layout graph objects using arbitrary layout
     engines. The default engine (and so far the only implemented
     engine) is ATT's Graphviz.

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

     layoutGraph(x, layoutFun = layoutGraphviz, ...)

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

       x: A graph object 

layoutFun: A function that performs the graph layout and returns a
          graph object with all necessary rendering information 

     ...: Further arguments that are passed to 'layoutFun' 

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

     Layout of a graph and its rendering are two separate processes.
     'layoutGraph' provides an API to use an arbitrary algorithm for
     the layout. This is archived by abstraction of the layout process
     into a separate function ('layoutFun') with well-defined inputs
     and outputs. The only requirements on the 'layoutFun' are to
     accept a graph object as input and to return a valid graph object
     with all the necessary rendering information stored in its
     'renderInfo' slot. This information comprises

     *for nodes:*



     _n_o_d_e_X, _n_o_d_e_Y the locations of the nodes, in the coordinate system
          defined by 'bbox' (see below). 

     _l_W_i_d_t_h, _r_W_i_d_t_h the width components of the nodes,
          'lWidth+rWidth=total width'. 

     _h_e_i_g_h_t the heights of the nodes. 

     _l_a_b_e_l_X, _l_a_b_e_l_Y node label locations. 

     _l_a_b_e_l_J_u_s_t the justification of the node labels. 

     _l_a_b_e_l node label text. 

     _s_h_a_p_e the node shape. Valid values are 'box', 'rectangle',
          'ellipse', 'plaintext', 'circle' and 'triangle'. 


     *for edges:*



     _s_p_l_i_n_e_s representation of the edge splines as a list of
          'BezierCurve' objects. 

     _l_a_b_e_l_X, _l_a_b_e_l_Y edge label locations. 

     _l_a_b_e_l edge label text. 

     _a_r_r_o_w_h_e_a_d, _a_r_r_o_w_t_a_i_l some of Graphviz's arrow shapes are
          supported. Currently they are: 'open', 'normal', 'dot',
          'odot', 'box', 'obox', 'tee', 'diamond', 'odiamond' and
          'none'. In addition, a user-defined function can be passed
          which needs to be able to deal with 4 arguments: A list of xy
          coordinates for the center of the arrowhead, and the
          graphical parameters 'col', 'lwd' and 'lty'.

     _d_i_r_e_c_t_i_o_n The edge direction. The special value 'both' is used
          when reciprocrated edges are to be collapsed. 


     To indicate that this information has been added to the graph, the
     graph plotting function should also set the laidout flag in the
     'graphData' slot to 'TRUE' and add the bounding box information
     (i.e., the coordinate system in which the graph is laid out) in
     the format of a two-by-two matrix as item 'bbox' in the
     'graphData' slot.

     AT&T's 'Graphviz' is the default layout algorithm to use when
     'layoutGraph' is called without a specific 'layoutFun' function.
     See 'agopen' for details about how to tweak 'Graphviz' and the
     valid arguments that can be passed on through .... The most common
     ones to set in this context might be 'layoutType', which controls
     the type of layout to compute and the 'nodeAttrs' and 'edgeAttrs'
     arguments, which control the fine-tuning of nodes and edges.

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

     An object inheriting from class 'graph'

_N_o_t_e:

     Please note that the layout needs to be recomputed whenever
     attributes are changed which are bound to affect the position of
     nodes or edges. This is for instance the case for the 'arrowhead'
     and 'arrowtail' parameters.

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

     Florian Hahne, Deepayan Sarkar

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

     'renderGraph', 'graph.par', 'nodeRenderInfo', 'edgeRenderInfo',
     'agopen',

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

     library(graph)
     set.seed(123)
     V <- letters[1:5]
     M <- 1:2
     g1 <- randomGraph(V, M, 0.5)
     edgemode(g1) <- "directed"
     x <- layoutGraph(g1)
     renderGraph(x)

     ## one of Graphviz's additional layout algorithms
     x <- layoutGraph(g1, layoutType="neato")
     renderGraph(x)

     ## some tweaks to Graphviz's node and edge attributes,
     ## including a user-defined arrowhead and node shape functions.
     myArrows <- function(x, ...)
     {
     for(i in 1:4)
     points(x,cex=i)
     }

     myNode <- function(x, col, fill, ...)
     symbols(x=mean(x[,1]), y=mean(x[,2]), thermometers=cbind(.5, 1,
     runif(1)), inches=0.5,
     fg=col, bg=fill, add=TRUE)

     eAtt <- list(arrowhead=c("a~b"=myArrows, "b~d"="odiamond", "d~e"="tee"))
     nAtt <- list(shape=c(d="box", c="ellipse", a=myNode))
     edgemode(g1) <- "directed"
     x <- layoutGraph(g1, edgeAttrs=eAtt, nodeAttrs=nAtt, layoutType="neato")
     renderGraph(x)

