levelplot              package:lattice              R Documentation

_L_e_v_e_l _P_l_o_t_s

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

     Draw Level Plots and Contour plots.

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

     levelplot(formula, data,
               at,
               contour = FALSE,
               cuts = 15,
               pretty = FALSE,
               region = TRUE,
               ...,
               col.regions = trellis.par.get("regions")$col,
               colorkey = region)
     contourplot(formula, data, at,
                 contour = TRUE,
                 labels = format(at),
                 cuts = 7,
                 pretty = TRUE,
                 ...)

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

 formula: a formula of the form 'z ~ x * y | g1 * g2 * ...', where 'z'
          is a numeric response, and 'x, y' are numeric values
          evaluated on a rectangular grid. 

          'g1,g2,...', if present, must be either factors or shingles.

          Calculations are based on the assumption that all x and y
          values are evaluated on a grid (defined by '(unique(x))' and
          '(unique(y))'. The function will not return an error if this
          is not true, but the display might be nonsense.

          However, the x and y values need not be equally spaced. See
          example below with log scales.

          As an extension to partially support the form used in
          'filled.contour' and 'image', 'formula' can be a matrix. 

    data: optional data frame in which variables are to be evaluated  

      at: numeric vector giving breaks along the range of 'z'. Contours
          (if any) will be drawn at these heights, and the regions in
          between would be colored using 'col.regions'. 

col.regions: color vector to be used if regions is TRUE. The general
          idea is that this should be a color vector of moderately
          large length (longer than the number of regions. By default
          this is 100). It is expected that this vector would be
          gradually varying in color (so that nearby colors would be
          similar), and so when the colors are actually chosen, they
          are chosen to be equally spaced along this vector. When there
          are more regions than col.regions, the colors are recycled. 

colorkey: logical specifying whether a color key is to be drawn
          alongside the plot, or a list describing the color key. The
          list may contain the following components:

          'space' location of the colorkey, can be one of ``left'',
          ``right'', ``top'' and ``bottom''. Defaults to ``right''.

          'x,y' location, currently unused

          'col' vector of colors

          'at' numeric vector specifying where the colors change. must
          be of length 1 more than the col vector.

          'labels' a character vector for labelling the 'at' values, or
          more commonly, a list of components 'labels, at, cex, col,
          font' describing label positions.

          'tick.number' approximate number of ticks.

          'corner' interacts with x, y; unimplemented

          'width' width of the key in terms of character widths

          'height' length of key w.r.t side of plot. 

 contour: logical, whether to draw contour lines. 

    cuts: number of levels the range of 'z' would be divided into

  labels: logical specifying whether contour lines should be labelled,
          or character vector of labels for contour lines. This is not
          well-implemented yet, don't count on it. The type of
          labelling can be controlled by the 'label.style' argument,
          which is passed on to 'panel.levelplot' 

  pretty: logical, whether to use pretty labels

  region: logical, whether regions between contour lines should be
          filled 

     ...: other arguments

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

     These and all other high level Trellis functions have several
     arguments in common. These are extensively documented only in the
     help page for 'xyplot', which should be consulted to learn more
     detailed usage.

     Other useful arguments are mentioned in the help page for the
     default panel function 'panel.levelplot' (these are formally
     arguments to the panel function, but can be specified in the high
     level calls directly).

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

     An object of class ``trellis''. The `update' method can be used to
     update components of the object and the `print' method (usually
     called by default) will plot it on an appropriate plotting device.

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

     Deepayan Sarkar deepayan@stat.wisc.edu

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

     'xyplot', 'Lattice', 'panel.levelplot'

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

     x <- seq(pi/4, 5*pi, length = 100)
     y <- seq(pi/4, 5*pi, length = 100)
     r <- as.vector(sqrt(outer(x^2, y^2, "+")))
     grid <- expand.grid(x=x, y=y)
     grid$z <- cos(r^2) * exp(-r/(pi^3))
     levelplot(z~x*y, grid, cuts = 50, xlab="", ylab="",
               main="Weird Function", colorkey = FALSE)
     levelplot(z~x*y, grid, cuts = 50, scales=list(log="e"), xlab="",
               ylab="", main="Weird Function", sub="with log scales",
               colorkey = FALSE, region = TRUE)
     #S+ example
     library(modreg)
     data(environmental)
     attach(environmental)
     ozo.m <- loess((ozone^(1/3)) ~ wind * temperature * radiation,
            parametric = c("radiation", "wind"), span = 1, degree = 2)
     w.marginal <- seq(min(wind), max(wind), length = 50)
     t.marginal <- seq(min(temperature), max(temperature), length = 50)
     r.marginal <- seq(min(radiation), max(radiation), length = 4)
     wtr.marginal <- list(wind = w.marginal, temperature = t.marginal,
             radiation = r.marginal)
     grid <- expand.grid(wtr.marginal)
     grid[, "fit"] <- c(predict(ozo.m, grid))
     contourplot(fit ~ wind * temperature | radiation, data = grid,
               cuts = 10, region = TRUE,
               xlab = "Wind Speed (mph)",
               ylab = "Temperature (F)",
               main = "Cube Root Ozone (cube root ppb)",
               col.regions = trellis.par.get("regions")$col)
     detach()

