R: Default Panel Function for xyplot

F_1_panel.xyplot {lattice}

R Documentation

Default Panel Function for xyplot

Description

This is the default panel function for xyplot. Also see panel.superpose. The default panel functions for splom and qq are essentially the same function.

Usage

panel.xyplot(x, y, type = "p",
             groups = NULL,
             pch, col, col.line, col.symbol,
             font, fontfamily, fontface,
             lty, cex, fill, lwd,
             horizontal = FALSE, ...,
             smooth = NULL,
             grid = lattice.getOption("default.args")$grid,
             abline = NULL,
             jitter.x = FALSE, jitter.y = FALSE,
             factor = 0.5, amount = NULL,
             identifier = "xyplot")
panel.splom(..., identifier = "splom")
panel.qq(..., identifier = "qq")

Arguments

`x`, `y`	variables to be plotted in the scatterplot
`type`	character vector controlling how `x` and `y` are to be plotted. Can consist of one or more of the following: `"p"`, `"l"`, `"h"`, `"b"`, `"o"`, `"s"`, `"S"`, `"g"`, `"r"`, `"a"`, `"smooth"`, and `"spline"`. If `type` has more than one element, an attempt is made to combine the effect of each of the components. The behaviour if any of the first five are included in `type` is similar to the effect of the corresponding `type` in `plot`: `"p"` and `"l"` stand for points and lines respectively; `"b"` and `"o"` (for ‘overlay’) plot both; `"h"` draws vertical (or horizontal if `horizontal = TRUE`) line segments from the points to the origin. Types `"s"` and `"S"` are like `"l"` in the sense that they join consecutive points, but instead of being joined by a straight line, points are connected by a vertical and a horizontal segment forming a ‘step’, with the vertical segment coming first for `"s"`, and the horizontal segment coming first for `"S"`. Types `"s"` and `"S"` sort the values along one of the axes (depending on `horizontal`); this is unlike the behavior in `plot`. For the latter behavior, use `type = "s"` with `panel = panel.points`. Type `"g"` adds a reference grid using `panel.grid` in the background, but using the `grid` argument is now the preferred way to do so. The remaining values of `type` lead to various types of smoothing. This can also be achieved using the `smooth` argument, or by calling the relevant panel functions directly. The panel functions provide finer control over graphical and other parameters, but using `smooth` or `type` is convenient for simple usage. Using `smooth` is recommended, but `type` is also supported for backwards compatibility. Type `"r"` adds a linear regression line, `"smooth"` adds a loess fit, `"spline"` adds a cubic smoothing spline fit, and `"a"` draws line segments joining the average `y` value for each distinct `x` value. See `smooth` for details. See `example(xyplot)` and `demo(lattice)` for examples.
`groups`	an optional grouping variable. If present, `panel.superpose` will be used instead to display each subgroup
`col`, `col.line`, `col.symbol`	default colours are obtained from `plot.symbol` and `plot.line` using `trellis.par.get`.
`font`, `fontface`, `fontfamily`	font used when `pch` is a character
`pch`, `lty`, `cex`, `lwd`, `fill`	other graphical parameters. `fill` serves the purpose of `bg` in `points` for certain values of `pch`
`horizontal`	A logical flag controlling the orientation for certain `type`'s, e.g., `"h"`, `"s"`, ans `"S"` and the result of smoothing.
`...`	Extra arguments, if any, for `panel.xyplot`. Usually passed on as graphical parameters to low level plotting functions, or to the panel functions performing smoothing, if applicable.
`smooth`	If specificied, indicates the type of smooth to be added. Can be a character vector containing one or more values from `"lm"`, `"loess"`, `"spline"`, and `"average"`. Can also be a logical flag; `TRUE` is interpreted as `"loess"`. Each of these result in calling a corresponding panel function as described below; the `smooth` argument simply provides a convenient shortcut. `"lm"` adds a linear regression line (same as `panel.lmline`, except for default graphical parameters). `"loess"` adds a loess fit (same as `panel.loess`). `"spline"` adds a cubic smoothing spline fit (same as `panel.spline`). `"average"` has the effect of calling `panel.average`, which in conjunction with a `groups` argument can be useful for creating interaction plots. Normally, smoothing is performed with the `y` variable as the response and the `x` variable as the predictor. However, the roles of `x` and `y` are reversed if `horizontal = TRUE`.
`grid`	A logical flag, character string, or list specifying whether and how a background grid should be drawn. This provides the same functionality as `type="g"`, but is the preferred alternative as the effect `type="g"` is conceptually different from that of other `type` values (which are all data-dependent). Using the `grid` argument also allows more flexibility. Most generally, `grid` can be a list of arguments to be supplied to `panel.grid`, which is called with those arguments. Three shortcuts are available: `TRUE`: roughly equivalent to `list(h = -1, v = -1)` `"h"`: roughly equivalent to `list(h = -1, v = 0)` `"v"`: roughly equivalent to `list(h = 0, v = -1)` No grid is drawn if `grid = FALSE`.
`abline`	A numeric vector or more generally a list containing arguments that are used to call `panel.abline`. If specified as a numeric vector, `abline` is used as the first unnamed argument to `panel.abline`. This allows arguments of the form `abline = c(0, 1)`, which adds the diagonal line, or `abline = coef(fm)` to fit the regression line from a fitted mode. Use the list form for finer control; e.g., `abline = list(h = 0, v = 0, col = "grey")`. For more flexibility, use `panel.abline` directly.
`jitter.x`, `jitter.y`	logical, whether the data should be jittered before being plotted.
`factor`, `amount`	controls amount of jittering.
`identifier`	A character string that is prepended to the names of grobs that are created by this panel function.

Details

Creates scatterplot of x and y, with various modifications possible via the type argument. panel.qq draws a 45 degree line before calling panel.xyplot.

Note that most of the arguments controlling the display can be supplied directly to the high-level (e.g. xyplot) call.

Author(s)

Deepayan Sarkar Deepayan.Sarkar@R-project.org

Examples


types.plain <- c("p", "l", "o", "r", "g", "s", "S", "h", "a", "smooth")
types.horiz <- c("s", "S", "h", "a", "smooth")
horiz <- rep(c(FALSE, TRUE), c(length(types.plain), length(types.horiz)))

types <- c(types.plain, types.horiz)

x <- sample(seq(-10, 10, length.out = 15), 30, TRUE)
y <- x + 0.25 * (x + 1)^2 + rnorm(length(x), sd = 5)

xyplot(y ~ x | gl(1, length(types)),
       xlab = "type", 
       ylab = list(c("horizontal=TRUE", "horizontal=FALSE"), y = c(1/6, 4/6)),
       as.table = TRUE, layout = c(5, 3),
       between = list(y = c(0, 1)),
       strip = function(...) {
           panel.fill(trellis.par.get("strip.background")$col[1])
           type <- types[panel.number()]
           grid::grid.text(label = sprintf('"%s"', type), 
                           x = 0.5, y = 0.5)
           grid::grid.rect()
       },
       scales = list(alternating = c(0, 2), tck = c(0, 0.7), draw = FALSE),
       par.settings = 
       list(layout.widths = list(strip.left = c(1, 0, 0, 0, 0))),
       panel = function(...) {
           type <- types[panel.number()]
           horizontal <- horiz[panel.number()]
           panel.xyplot(..., 
                        type = type,
                        horizontal = horizontal)
       })[rep(1, length(types))]

[Package lattice version 0.22-6 Index]