R: Display Contours

contour {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, 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 `NULL`, the current font family and face are used for the contour labels. If a character vector of length 2 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). The default is `NULL` on graphics devices with high-quality rotation of text and `c("sans serif", "plain")` otherwise.
`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)

[Package graphics version 2.8.1 Index]