dendrogramGrob         package:latticeExtra         R Documentation

_C_r_e_a_t_e _a _G_r_o_b _R_e_p_r_e_s_e_n_t_i_n_g _a _D_e_n_d_r_o_g_r_a_m

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

     This function creates a grob (a grid graphics object) that can be
     manipulated as such.  In particular, it can be used as a legend in
     a lattice display like 'levelplot' to form heatmaps.

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

     dendrogramGrob(x, ord = order.dendrogram(x),
                    side = c("right", "top"),
                    add = list(), size = 5, size.add = 1,
                    type = c("rectangle", "triangle"),
                    ...)

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

       x: An object of class '"dendrogram"'.  See 'dendrogram' for
          details 

     ord: A vector of integer indices giving the order in which the
          terminal leaves are to be plotted.  If this is not the same
          as 'order.dendrogram(x)', then the leaves may not cluster
          together and branches of the dendrogram may intersect.  

    side: Intended position of the dendrogram when added in a heatmap. 
          Currently allowed positions are '"right"' and '"top"'. 

     add: Additional annotation.  Currently, it is only possible to add
          one or more rows of rectangles at the base of the dendrogram.
          See details below.  

    size: Total height of the dendrogram in '"lines"' (see 'unit') 

size.add: Size of each additional row, also in '"lines"' 

    type: Whether a child node is joined to its parent  directly with a
          straight line ('"triangle"') or as a "stair" with two lines
          ('"rectangle"') 

     ...: ~~Describe '...' here~~ 

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

     The 'add' argument can be used for additional annotation at the
     base of the dendrogram.  It should be a list with one component
     for each row, with names specifying the type of annotation and
     components specifying the contents.  Currently, the only supported
     name is '"rect"' (which can be repeated), producing rectangles. 
     The components in such a case is a list of graphical parameters,
     possibly vectorized, that are passed on to 'gpar'.

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

     An object of class '"grob"'

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

     Deepayan Sarkar deepayan.sarkar@r-project.org

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

     'heatmap', 'levelplot'

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

     data(mtcars)
     x  <- t(as.matrix(scale(mtcars)))
     dd.row <- as.dendrogram(hclust(dist(x)))
     row.ord <- order.dendrogram(dd.row)

     dd.col <- as.dendrogram(hclust(dist(t(x))))
     col.ord <- order.dendrogram(dd.col)

     library(lattice)

     levelplot(x[row.ord, col.ord],
               aspect = "fill",
               scales = list(x = list(rot = 90)),
               colorkey = list(space = "left"),
               legend =
               list(right =
                    list(fun = dendrogramGrob,
                         args =
                         list(x = dd.col, ord = col.ord,
                              side = "right",
                              size = 10)),
                    top =
                    list(fun = dendrogramGrob,
                         args =
                         list(x = dd.row, 
                              side = "top",
                              type = "triangle"))))

     levelplot(x[, col.ord],
               aspect = "iso",
               scales = list(x = list(rot = 90)),
               colorkey = FALSE,
               legend =
               list(right =
                    list(fun = dendrogramGrob,
                         args =
                         list(x = dd.col, ord = col.ord,
                              side = "right",
                              size = 10)),
                    top =
                    list(fun = dendrogramGrob,
                         args =
                         list(x = dd.row, ord = sort(row.ord),
                              side = "top", size = 10,
                              type = "triangle"))))

