contour               package:graphics               R Documentation

Display Contours

Description:

     Create a contour plot, or add contour lines to an existing plot.

Usage:

     contour(x, ...)

     ## Default S3 method:
     contour(x = seq(0, 1, length.out = nrow(z)),
             y = seq(0, 1, length.out = ncol(z)),
             z,
             nlevels = 10, levels = pretty(zlim, nlevels),
             labels = NULL,
             xlim = range(x, finite = TRUE),
             ylim = range(y, finite = TRUE),
             zlim = range(z, finite = TRUE),
             labcex = 0.6, drawlabels = TRUE, method = "flattest",
             vfont = c("sans serif", "plain"),
             axes = TRUE, frame.plot = axes,
             col = par("fg"), lty = par("lty"), lwd = par("lwd"),
             add = FALSE, ...)

Arguments:

     x,y: locations of grid lines at which the values in 'z' are
          measured.  These must be in ascending order.  By default,
          equally spaced values from 0 to 1 are used.  If 'x' is a
          'list', its components 'x$x' and 'x$y' are used for 'x' and
          'y', respectively. If the list has component 'z' this is used
          for 'z'.

       z: a matrix containing the values to be plotted ('NA's are
          allowed).  Note that 'x' can be used instead of 'z' for
          convenience.

 nlevels: number of contour levels desired *iff* 'levels' is not
          supplied.

  levels: numeric vector of levels at which to draw contour lines.

  labels: a vector giving the labels for the contour lines.  If 'NULL'
          then the levels are used as labels, otherwise this is coerced
          by 'as.character'.

  labcex: 'cex' for contour labelling.  This is an absolute size, not a
          multiple of 'par("cex")'.

drawlabels: logical.  Contours are labelled if 'TRUE'.

  method: character string specifying where the labels will be located.
          Possible values are '"simple"', '"edge"' and '"flattest"'
          (the default).  See the 'Details' section.

   vfont: if a character vector of length 2 is specified, then Hershey
          vector fonts are used for the contour labels. The first
          element of the vector selects a typeface and the second
          element selects a fontindex (see 'text' for more
          information).

xlim, ylim, zlim: x-, y- and z-limits for the plot.

axes, frame.plot: logical indicating whether axes or a box should be
          drawn, see 'plot.default'.

     col: color for the lines drawn.

     lty: line type for the lines drawn.

     lwd: line width for the lines drawn.

     add: logical. If 'TRUE', add to a current plot.

     ...: additional arguments to 'plot.window', 'title', 'Axis' and
          'box', typically graphical parameters such as 'cex.axis'.

Details:

     'contour' is a generic function with only a default method in base
     R.

     The methods for positioning the labels on contours are '"simple"'
     (draw at the edge of the plot, overlaying the contour line),
     '"edge"' (draw at the edge of the plot, embedded in the contour
     line, with no labels overlapping) and '"flattest"' (draw on the
     flattest section of the contour, embedded in the contour line,
     with no labels overlapping).  The second and third may not draw a
     label on every contour line.

     For information about vector fonts, see the help for 'text' and
     'Hershey'.

     Notice that 'contour' interprets the 'z' matrix as a table of
     'f(x[i], y[j])' values, so that the x axis corresponds to row
     number and the y axis to column number, with column 1 at the
     bottom, i.e. a 90 degree clockwise rotation of the conventional
     textual layout.

     Alternatively, use 'contourplot' from the 'lattice' package where
     the 'formula' notation allows to use vectors 'x,y,z' of the same
     length.

     There is limited control over the axes and frame as arguments
     'col', 'lwd' and 'lty' refer to the contour lines (rather than
     being general graphical parameters).  For more control, add
     contours to a plot, or add axes and frame to a contour plot.

References:

     Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
     Language_. Wadsworth & Brooks/Cole.

See Also:

     'options("max.countour.segments")' for the maximal complexity of a
     single contour line.

     'contourLines', 'filled.contour' for color-filled contours,
     'contourplot' (and 'levelplot') from package 'lattice'.  Further,
     'image' and the graphics demo which can be invoked as
     'demo(graphics)'.

Examples:

     require(grDevices) # for colours
     x <- -6:16
     op <- par(mfrow = c(2, 2))
     contour(outer(x, x), method = "edge", vfont = c("sans serif", "plain"))
     z <- outer(x, sqrt(abs(x)), FUN = "/")
     image(x, x, z)
     contour(x, x, z, col = "pink", add = TRUE, method = "edge",
             vfont = c("sans serif", "plain"))
     contour(x, x, z, ylim = c(1, 6), method = "simple", labcex = 1)
     contour(x, x, z, ylim = c(-6, 6), nlev = 20, lty = 2, method = "simple")
     par(op)

     ## Persian Rug Art:
     x <- y <- seq(-4*pi, 4*pi, len = 27)
     r <- sqrt(outer(x^2, y^2, "+"))
     opar <- par(mfrow = c(2, 2), mar = rep(0, 4))
     for(f in pi^(0:3))
       contour(cos(r^2)*exp(-r/f),
               drawlabels = FALSE, axes = FALSE, frame = TRUE)

     rx <- range(x <- 10*1:nrow(volcano))
     ry <- range(y <- 10*1:ncol(volcano))
     ry <- ry + c(-1,1) * (diff(rx) - diff(ry))/2
     tcol <- terrain.colors(12)
     par(opar); opar <- par(pty = "s", bg = "lightcyan")
     plot(x = 0, y = 0,type = "n", xlim = rx, ylim = ry, xlab = "", ylab = "")
     u <- par("usr")
     rect(u[1], u[3], u[2], u[4], col = tcol[8], border = "red")
     contour(x, y, volcano, col = tcol[2], lty = "solid", add = TRUE,
             vfont = c("sans serif", "plain"))
     title("A Topographic Map of Maunga Whau", font = 4)
     abline(h = 200*0:4, v = 200*0:4, col = "lightgray", lty = 2, lwd = 0.1)

     ## contourLines produces the same contour lines as contour
     line.list <- contourLines(x, y, volcano)
     plot(x = 0, y = 0,type = "n", xlim = rx, ylim = ry, xlab = "", ylab = "")
     u <- par("usr")
     rect(u[1], u[3], u[2], u[4], col = tcol[8], border = "red")
     contour(x, y, volcano, col = tcol[2], lty = "solid", add = TRUE,
                  vfont = c("sans serif", "plain"))
     templines <- function(clines) {
       lines(clines[[2]], clines[[3]])
     }
     invisible(lapply(line.list, templines))
     par(opar)

