Package 'latticeExtra'

Modal ancestry by County according to US 2000 Census

Description

This data set records the population and the three most frequently reported ancestries by US county, according to the 2000 census.

Usage

data(ancestry)

Format

A data frame with 3219 observations on the following 5 variables.

county

A factor. An attempt has been made to make the levels look similar to the county names used in the maps package.

population

a numeric vector

top

a character vector

second

a character vector

third

a character vector

Source

U.S. Census Bureau. The ancestry data were extracted from Summary File 3, available from

https://web.archive.org/web/20100703053258/http://www.census.gov/census2000/sumfile3.html

which is based on the ‘long form’ questionnaire (asked to 1 in 6 households surveyed).

References

https://web.archive.org/web/20100707180939/http://www.census.gov/prod/cen2000/doc/sf3.pdf

See Also

mapplot, for examples.

---

Overlay panels of Trellis plots on same or different scales

Description

Allows overlaying of Trellis plots, drawn on the same scales or on different scales in each of the x and y dimensions. There are options for custom axes and graphical styles.

Usage

as.layer(x, ...)

## S3 method for class 'trellis'
as.layer(x, x.same = TRUE, y.same = TRUE,
         axes = c(if (!x.same) "x", if (!y.same) "y"), opposite = TRUE,
         outside = FALSE, theme = x$par.settings, ...)

Arguments

x	a trellis object.
x.same	retains the existing panel x scale for the new layer, rather than using the layer's native x scale.
y.same	retains the existing panel y scale.
axes	which of the axes to draw (NULL for neither). Axes might not be drawn anyway, such as if scales$draw == FALSE.
opposite	whether to draw axes on the opposite side to normal: that is, the top and/or right sides rather than bottom and/or left. May be a vector of length 2 to specify for x and y axes separately.
outside	whether to draw the axes outside the plot region. Note that space for outside axes will not be allocated automatically. May be a vector of length 2 to specify for x and y axes separately.
theme	passed to layer.
...	passed to layer: typically the style argument would be specified.

Details

Panels from the trellis object x will be drawn in the corresponding panel of another trellis object, so packet numbers match (see examples).

Axis setting are taken from the trellis object x, so most scales arguments such as draw, at, labels etc will carry over to the overlaid axes. Only the main axis settings are used (i.e. left or bottom), even when opposite = TRUE.

Currently, outside top axes will be drawn in the strip if there are strips.

Value

an updated trellis object.

Author(s)

Felix Andrews [email protected]

See Also

doubleYScale, layer, panel.axis

Examples

b1 <- barley
b2 <- barley
b2$yield <- b2$yield + 10

## panels are matched up by packet number
dotplot(variety ~ yield | site * year, b1) +
  as.layer(dotplot(variety ~ yield | site * year, b2, col = "red"))

## which gives the same result as:
dotplot(variety ~ yield | site * year, data = b1, subscripts = TRUE) +
  layer(panel.dotplot(yield[subscripts], variety[subscripts], col = "red"),
        data = b2)


## example with all same scales (the default):
xyplot(fdeaths ~ mdeaths) +
  as.layer(xyplot(fdeaths ~ mdeaths, col = 2, subset = ldeaths > 2000))

## same x scales, different y scales:
xyplot(fdeaths ~ mdeaths) +
  as.layer(bwplot(~ mdeaths, box.ratio = 0.2), y.same = FALSE)

## same y scales, different x scales:
xyplot(fdeaths ~ mdeaths) +
  as.layer(bwplot(fdeaths ~ factor(mdeaths*0), box.ratio = 0.2), x.same = FALSE)

## as.layer() is called automatically if two plots are added:
histogram(~ ldeaths, type = "density") + densityplot(~ ldeaths, lwd = 3)

## applying one panel layer to several panels of another object
xyplot(Sepal.Length + Sepal.Width ~ Petal.Length + Petal.Width | Species,
       data = iris, scales = "free") +
   as.layer(levelplot(volcano), x.same = FALSE, y.same = FALSE, under = TRUE)

---

Hourly access attempts to Bioconductor website

Description

This data set records the hourly number of access attempts to the Bioconductor website (https://www.bioconductor.org) during January through May of 2007. The counts are essentially an aggregation of the number of entries in the access log.

Usage

data(biocAccess)

Format

A data frame with 3623 observations on the following 7 variables.

counts

the number of access attempts

day

the day of the month

month

a factor with levels Jan, Feb, ..., Dec

year

the year (all 2007)

hour

hour of the day, a numeric vector

weekday

a factor with levels Monday, Tuesday, ..., Sunday

time

a POSIXt representation of the start of the hour

Examples

data(biocAccess)
xyplot(stl(ts(biocAccess$counts[1:(24 * 30)], frequency = 24), "periodic"))

---

Merge trellis objects, using same or different scales

Description

Combine the panels of multiple trellis objects into one.

Usage

## S3 method for class 'trellis'
c(..., x.same = NA, y.same = NA,
    layout = NULL, merge.legends = FALSE, recursive = FALSE)

xyplot.list(x, data = NULL, ..., FUN = xyplot,
    y.same = TRUE, x.same = NA, layout = NULL,
    merge.legends = FALSE)

Arguments

...	two or more trellis objects. If these are named arguments, the names will be used in the corresponding panel strips.
x.same	if TRUE, set the x scale relation to "same" and recalculate panel limits using data from all panels. Otherwise, the x scales in each panel will be as they were in the original objects (so in general not the same), the default behaviour.
y.same	as above, for y scales. Note that xyplot.list defaults to same y scales. Set to NA to leave them alone.
layout	value for layout of the new plot; see xyplot.
merge.legends	to keep keys or legends from all plots, not just the first. If multiple legends share the same "space", they are packed together horizontally or vertically.
recursive	for consistency with the generic method, ignored.
x	a list of objects to plot individually, and then be combined into one final plot.
FUN, data	a lattice plot function, to be called on each element of the list x, along with data and ...

Details

This mechanism attempts to merge the panels from multiple trellis objects into one. The same effect could generally be achieved by either a custom panel function (where the display depends on packet.number()), or using print.trellis to display multiple trellis objects. However, in some cases it is more convenient to use c(). Furthermore, it can be useful to maintain the display as a standard lattice display, rather than a composite using print.trellis, to simplify further interaction.

Many properties of the display, such as titles, axis settings and aspect ratio will be taken from the first object only.

Note that combining panels from different types of plots does not really fit the trellis model. Some features of the plot may not work as expected. In particular, some work may be needed to show or hide scales on selected panels. An example is given below.

Any trellis object with more than one conditioning variable will be "flattened" to one dimension, eliminating the multi-variate conditioning structure.

Value

a new trellis object.

Author(s)

Felix Andrews [email protected]

See Also

marginal.plot was the original motivating application, print.trellis, update.trellis, trellis.object

Examples

## Combine different types of plots.
c(wireframe(volcano), contourplot(volcano))

## Merging levelplot with xyplot
levObj <- levelplot(prop.table(WorldPhones, 1) * 100)
xyObj <- xyplot(Phones ~ Year, data.frame(Phones = rowSums(WorldPhones),
      Year = row.names(WorldPhones)), type="b", ylim = c(0, 150000))
## NOTE: prepanel.levelplot (from first object) is used for entire plot.
cObj <- c(levObj, xyObj, layout = 1:2)
update(cObj, scales = list(y = list(rot = 0)),
       ylab = c("proportional distribution", "number of phones"))

## Combine two xyplots.
sepals <- xyplot(Sepal.Length ~ Sepal.Width, iris, groups = Species,
    xlab = "Width", ylab = "Height")
petals <- xyplot(Petal.Length ~ Petal.Width, iris, groups = Species)
c(Sepals = sepals, Petals = petals)

## Force same scales (re-calculate panel limits from merged data):
c(Sepals = sepals, Petals = petals, x.same = TRUE, y.same = TRUE)

## Or - create xyplots from a list of formulas
xyplot.list(list(Sepals = Sepal.Length ~ Sepal.Width,
                 Petals = Petal.Length ~ Petal.Width),
             data = iris, groups = Species, x.same = TRUE,
             xlab = "Width", ylab = "Height")

## Create histograms from a list of objects, and merge them.
xyplot.list(iris, FUN = histogram)

## Create cumulative distribution plots from a list of objects
xyplot.list(iris[1:4], FUN = qqmath, groups = iris$Species,
            auto.key = TRUE)

## Display a table as both frequencies and proportions:
data(postdoc)
## remove last row (containing totals)
postdoc <- postdoc[1:(nrow(postdoc)-1),]
pdprops <- barchart(prop.table(postdoc, margin = 1),
                    auto.key = list(adj = 1))
pdmargin <- barchart(margin.table(postdoc, 1))
pdboth <- c(pdprops, pdmargin)
update(pdboth, xlab = c("Proportion", "Freq"))

## Conditioned 'quakes' plot combined with histogram.
qua <- xyplot(lat ~ long | equal.count(depth, 3), quakes,
    aspect = "iso", pch = ".", cex = 2, xlab = NULL, ylab = NULL)
qua <- c(qua, depth = histogram(quakes$depth), layout = c(4, 1))
## suppress scales on the first 3 panels
update(qua, scales = list(at = list(NULL, NULL, NULL, NA),
                          y = list(draw = FALSE)))

## Demonstrate merging of legends and par.settings.
## Note that par.settings can conflict, thus need col.line=...
mypoints <- 
    xyplot(1:10 ~ 1:10, groups = factor(rep(1:2, each = 5)),
        par.settings = simpleTheme(pch = 16), auto.key = TRUE)
mylines <-
    xyplot(1:10 ~ 1:10, groups = factor(rep(1:5, each = 2)),
        type = "l", par.settings = simpleTheme(col.line = 1:5),
        auto.key = list(lines = TRUE, points = FALSE, columns = 5))
c(mypoints, mylines)

## Visualise statistical and spatial distributions
## (advanced!). Requires the 'maps' package to be installed

if (require(maps)) {
    vars <- as.data.frame(state.x77)
    StateName <- tolower(state.name)
    form <- StateName ~ Population + Income + Illiteracy +
        `Life Exp` + Murder + `HS Grad` + Frost + sqrt(Area)
    ## construct independent maps of each variable
    statemap <- map("state", plot = FALSE, fill = TRUE)
    colkey <- draw.colorkey(list(col = heat.colors(100), at = 0:100,
                                 labels = list(labels = c("min","max"), at = c(0,100))))
    panel.mapplot.each <- function(x, breaks, ...)
        panel.mapplot(x = x, breaks = quantile(x), ...)
    vmaps <- mapplot(form, vars, map = statemap, colramp = heat.colors,
                     panel = panel.mapplot.each, colorkey = FALSE,
                     legend = list(right = list(fun = colkey)), xlab = NULL)
    ## construct independent densityplots of each variable
    vdens <- densityplot(form[-2], vars, outer = TRUE, cut = 0, 
                         scales = list(relation = "free"), ylim = c(0, NA),
                         cex = 0.5, ref = TRUE) +
        layer(panel.axis("top", half = FALSE, text.cex = 0.7))
    ## combine panels from both plots
    combo <- c(vmaps, vdens)
    ## rearrange in pairs
    n <- length(vars)
    npairs <- rep(1:n, each = 2) + c(0, n)
    update(combo[npairs], scales = list(draw = FALSE),
           layout = c(4, 4), between = list(x = c(0, 0.5), y = 0.5))
}

---

Combine axis limits across margins

Description

Modifies a "trellis" object with "free" scales so that panel limits are extended to be the same across selected conditioning variables (typically rows and columns).

Usage

combineLimits(x, margin.x = 2L, margin.y = 1L,
              extend = TRUE, adjust.labels = TRUE)

Arguments

x	An object of class "trellis".
margin.x	Integer vector specifying which conditioning variables to combine the x-axis limits over. Defaults to the second conditioning variable (rows in the default layout); that is, the limit of each packet is extended to include the limits of all other packets obtained by varying the level of the second conditioning variable (row). More than one variable can be specified; for example, margin.x = c(1, 2) would ensure that limits are extended to include all levels in both the first and second conditioning variables. In case there is a third conditioning variable, this would have the effect of per-page x-axis limits with the default layout.
margin.y	Integer vector specifying which conditioning variables to combine the x-axis limits over. Similar to margin.x, but defaults to the first conditioning variable (columns in the default layout).
extend	Logical flag indicating whether the limits should be extended after being combined. Usually a good idea.
adjust.labels	Logical flag indicating whether labels should be removed from all but the boundaries. This may give misleading plots with non-default layouts.

Details

combineLimits is useful mainly for plots with two conditioning variables with the default layout (columns and rows correspond to the first and second conditioning variables), when per-row and per-column limits are desired.

The lattice approach does not tie levels of the conditioning variables to the plot layout, so it is possible that all panels in a row (or column) do not represent the same level. It should be noted that combineLimits actually combines limits across levels, and not across rows and columns. Results are likely to be misleading unless the default layout is used.

Value

An object of class "trellis"; essentially the same as x, but with certain properties modified.

Note

Does not work for all "trellis" objects. In particular, log-scales do not yet work. Fancy layouts with skip-ped panels and unusual packet-to-panel mappings will probably also not work.

Author(s)

Deepayan Sarkar

See Also

Lattice, xyplot

Examples

data(Cars93, package = "MASS")

## FIXME: log scales don't yet work

pcars <- 
    xyplot(Price ~ EngineSize | reorder(AirBags, Price) + Cylinders,
           data = Cars93, 
           subset = Cylinders != "rotary" & Cylinders != "5", 
           scales = list(relation = "free",
                         y = list(log = FALSE, tick.number = 3, rot = 0)),
           xlab = "Engine Size (litres)", 
           ylab = "Average Price (1000 USD)",
           as.table = TRUE) 

combineLimits(pcars)

useOuterStrips(combineLimits(update(pcars, grid = TRUE),
                             margin.x = c(1, 2), adjust.labels = FALSE))

useOuterStrips(combineLimits(update(pcars, grid = TRUE)))

---

Create a lattice theme based on specified colors

Description

Creates a lattice theme given a few colors. Non-color settings are not included. The colors are typically used to define the standard grouping (superposition) colors, and the first color is used for ungrouped displays.

Usage

custom.theme(symbol = RColorBrewer::brewer.pal(n = 8, name = "Dark2"),
             fill = RColorBrewer::brewer.pal(n = 12, name = "Set3"),
             region = RColorBrewer::brewer.pal(n = 11, name = "Spectral"),
             reference = "#e8e8e8",
             bg = "transparent",
             fg = "black",
             ...)

## different defaults ("Set1", "Accent", "RdBu"):
custom.theme.2(...)

Arguments

symbol	a vector of symbol colors.
fill	a vector of fill colors (for barcharts, etc.)
region	a vector of colors that is used to define a continuous color gradient using colorRampPalette
reference	a color for reference lines and such
bg	a background color
fg	a foreground color, primarily for annotation
...	further arguments passed to simpleTheme and used to modify the theme.

Value

A list that can be supplied to trellis.par.get or as the theme argument to trellis.device.

Author(s)

Deepayan Sarkar

Examples

set.seed(0)

## create a plot to demonstrate graphical settings
obj <-
xyplot(Sepal.Length + Sepal.Width ~ Petal.Length + Petal.Width, iris,
       type = c("p", "r"), jitter.x = TRUE, jitter.y = TRUE, factor = 5,
       auto.key = list(lines = TRUE, rectangles = TRUE))
obj <- update(obj, legend = list(right =
         list(fun = "draw.colorkey", args = list(list(at = 0:100)))))

## draw with default theme
obj

## draw with custom.theme()
update(obj, par.settings = custom.theme())

## create a theme with paired colours, filled points, etc
update(obj, par.settings =
  custom.theme(symbol = RColorBrewer::brewer.pal(12, "Paired"),
               fill = RColorBrewer::brewer.pal(12, "Paired"),
               region = RColorBrewer::brewer.pal(9, "Blues"),
               bg = "grey90", fg = "grey20", pch = 16))

## draw with custom.theme.2()
update(obj, par.settings = custom.theme.2())

---

Create a Grob Representing a Dendrogram

Description

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.

Usage

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

Arguments

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")
...	Extra arguments. Currently ignored.

Details

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.

Value

An object of class "grob"

Author(s)

Deepayan Sarkar [email protected]

See Also

heatmap, levelplot

Examples

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"))))


## Version with unsorted rows.

## For illustration, MPG ploted again at foot of dendrogram

mpg <- x["mpg", col.ord]
mpg.col <- level.colors(mpg, at = do.breaks(range(mpg), 10),
                        col.regions = terrain.colors)

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",
                         add = list(rect = list(fill = mpg.col)),
                         size = 10)),
               top =
               list(fun = dendrogramGrob,
                    args =
                    list(x = dd.row, ord = sort(row.ord),
                         side = "top", size = 10,
                         type = "triangle"))))

---

Draw two plot series with different y scales

Description

Overplot two trellis objects with different y scales, optionally in different styles, adding a second y axis, and/or a second y axis label.

Note: drawing plots with multiple scales is often a bad idea as it can be misleading.

Usage

doubleYScale(obj1, obj2, use.style = TRUE,
             style1 = if (use.style) 1, style2 = if (use.style) 2,
             add.axis = TRUE, add.ylab2 = FALSE,
             text = NULL, auto.key = if (!is.null(text))
               list(text, points = points, lines = lines, ...),
             points = FALSE, lines = TRUE, ..., under = FALSE)

Arguments

obj1, obj2	trellis objects. Note that most settings, like main/sub/legend/etc are taken only from obj1; only the panel, axis and ylab are taken from obj2.
use.style, style1, style2	style1 and style2 give the ‘group number’ for obj1 and obj2 respectively. The style is taken from these indices into the values of trellis.par.get("superpose.line"). Therefore these should be integers between 1 and 6; a value of 0 or NULL can be given to leave the default settings. These will also be applied to the y-axes and ylab, if relevant. use.style simply changes the defaults of the style arguments.
add.axis	if TRUE, draw a second y axis (for the obj2 series) on the right side of the plot.
add.ylab2	if TRUE, draw a second y axis label (from obj2$ylab) on the right side of the plot. Note, this will replace any existing key or legend on the right side, i.e. with space = "right".
text, auto.key, points, lines, ...	if non-NULL, add a key to the display, using entries named by text. Further arguments are passed on to simpleKey at plot time.
under	if TRUE, draw obj2 under obj1.

Details

Panels from the trellis object obj2 will be drawn in the corresponding panel of obj1.

Axis settings are taken from the trellis objects, so most scales arguments such as draw, at, labels etc from obj2 will carry over to the second y axis.

Value

a merged trellis object.

Author(s)

Felix Andrews [email protected]

See Also

as.layer

Examples

set.seed(1)
foo <- list(x = 1:100, y = cumsum(rnorm(100)))
## show original data
xyplot(y + y^2 ~ x, foo, type = "l")
## construct separate plots for each series
obj1 <- xyplot(y ~ x, foo, type = "l")
obj2 <- xyplot(y^2 ~ x, foo, type = "l")
## simple case: no axis for the overlaid plot
doubleYScale(obj1, obj2, add.axis = FALSE)
## draw second y axis
doubleYScale(obj1, obj2)
## ...with second ylab
doubleYScale(obj1, obj2, add.ylab2 = TRUE)
## ...or with a key
doubleYScale(obj1, obj2, text = c("obj1", "obj2"))
## ...with custom styles
update(doubleYScale(obj1, obj2, text = c("obj1", "obj2")),
  par.settings = simpleTheme(col = c('red','black'), lty = 1:2))

## different plot types
x <- rnorm(60)
doubleYScale(histogram(x), densityplot(x), use.style = FALSE)
## (but see ?as.layer for a better way to do this)

## multi-panel example
## a variant of Figure 5.13 from Sarkar (2008)
## http://lmdvr.r-forge.r-project.org/figures/figures.html?chapter=05;figure=05_13
data(SeatacWeather)
temp <- xyplot(min.temp + max.temp ~ day | month,
               data = SeatacWeather, type = "l", layout = c(3, 1))
rain <- xyplot(precip ~ day | month, data = SeatacWeather, type = "h")

doubleYScale(temp, rain, style1 = 0, style2 = 3, add.ylab2 = TRUE,
   text = c("min. T", "max. T", "rain"), columns = 3)

## re-plot with different styles
update(trellis.last.object(),
   par.settings = simpleTheme(col = c("black", "red", "blue")))

---

Climate of the East Coast of Australia

Description

A set of climate statistics for 16 coastal locations along Eastern Australia. These sites were chosen to be approximately equally spaced to cover the whole eastern coast of Australia. For each site, climate statistics were calculated for the standard 30-year period 1971-2000. Only sites with nearly-complete data were chosen.

Usage

data(EastAuClimate)

Format

A data frame with the following 10 variables and 5 items of metadata for each of 16 sites.

SummerMaxTemp

average daily maximum air temperature (degrees C) in February.

SummerMinTemp

average daily minimum air temperature (degrees C) in February.

WinterMaxTemp

average daily maximum air temperature (degrees C) in July.

WinterMinTemp

average daily minimum air temperature (degrees C) in July.

SummerRain

median total precipitation in February (mm/month).

WinterRain

median total precipitation in July (mm/month).

MeanAnnRain

average total amount of precipitation recorded in a year (mm/year).

RainDays

average number of days in a year with at least 1 mm of precipitation.

ClearDays

average number of clear days in a year. This statistic is derived from cloud cover observations, which are measured in oktas (eighths). A clear day is recorded when the mean of the 9 am and 3 pm cloud observations is less than or equal to 2 oktas.

CloudyDays

average number of clear days in a year. A cloudy day is recorded when the mean of the 9 am and 3 pm cloud observations is greater than or equal to 6 oktas.

ID

BOM Site number.

Latitude

Site latitude (degrees North).

Longitude

Site longitude (degrees East).

Elevation

Site elevation (m).

State

Australian state: TAS = Tasmania, VIC = Victoria, NSW = New South Wales, QLD = Queensland.

The row names of the data frame give the location names. Note: these are not the official names of the climate stations.

Source

Sites were chosen by hand from maps on the Bureau of Meteorology website. The data were extracted manually from web pages under http://www.bom.gov.au/climate/ and processed to extract a subset of statistics. - by Felix Andrews [email protected]

Bureau of Meteorology, Commonwealth of Australia. Product IDCJCM0026 Prepared at Wed 31 Dec 2008.

Definitions of statistics adapted from http://www.bom.gov.au/climate/cdo/about/about-stats.shtml

Examples

data(EastAuClimate)

## Compare the climates of state capital cities
EastAuClimate[c("Hobart", "Melbourne", "Sydney", "Brisbane"),]

## A function to plot maps (a Lattice version of maps::map)
lmap <-
   function(database = "world", regions = ".", exact = FALSE,
            boundary = TRUE, interior = TRUE, projection = "",
            parameters = NULL, orientation = NULL,
            aspect = "iso", type = "l",
            par.settings = list(axis.line = list(col = "transparent")),
            xlab = NULL, ylab = NULL, ...)
{
   theMap <- map(database, regions, exact = exact,
                 boundary = boundary, interior = interior,
                 projection = projection, parameters = parameters,
                 orientation = orientation, plot = FALSE)
   xyplot(y ~ x, theMap, type = type, aspect = aspect,
          par.settings = par.settings, xlab = xlab, ylab = ylab,
          default.scales = list(draw = FALSE), ...)
}

## Plot the sites on a map of Australia
if (require("maps")) {
  lmap(regions = c("Australia", "Australia:Tasmania"),
       exact = TRUE, projection = "rectangular",
       parameters = 150, xlim = c(130, 170),
       panel = function(...) {
          panel.xyplot(...)
          with(EastAuClimate, {
            panel.points(Longitude, Latitude, pch = 16)
            txt <- row.names(EastAuClimate)
            i <- c(3, 4)
            panel.text(Longitude[ i], Latitude[ i], txt[ i], pos = 2)
            panel.text(Longitude[-i], Latitude[-i], txt[-i], pos = 4)
          })
       })
}

## Average daily maximum temperature in July (Winter).
xyplot(WinterMaxTemp ~ Latitude, EastAuClimate, aspect = "xy",
       type = c("p", "a"), ylab = "Temperature (degrees C)")

## (Make a factor with levels in order - by coastal location)
siteNames <- factor(row.names(EastAuClimate),
           levels = row.names(EastAuClimate))
## Plot temperature ranges (as bars), color-coded by RainDays
segplot(siteNames ~ WinterMinTemp + SummerMaxTemp, EastAuClimate,
        level = RainDays, sub = "Color scale: number of rainy days per year",
        xlab = "Temperature (degrees C)",
        main = paste("Typical temperature range and wetness",
           "of coastal Australian cities", sep = "\n"))

## Show Winter and Summer temperature ranges separately
segplot(Latitude ~ WinterMinTemp + SummerMaxTemp, EastAuClimate,
   main = "Average daily temperature ranges \n of coastal Australian sites",
   ylab = "Latitude", xlab = "Temperature (degrees C)",
   par.settings = simpleTheme(lwd = 3, alpha = 0.5),
   key = list(text = list(c("July (Winter)", "February (Summer)")),
              lines = list(col = c("blue", "red"))),
   panel = function(x, y, z, ..., col) {
      with(EastAuClimate, {
         panel.segplot(WinterMinTemp, WinterMaxTemp, z, ..., col = "blue")
         panel.segplot(SummerMinTemp, SummerMaxTemp, z, ..., col = "red")
      })
   })

## Northern sites have Summer-dominated rainfall;
## Southern sites have Winter-dominated rainfall.
xyplot(SummerRain + WinterRain ~ Latitude, EastAuClimate,
       type = c("p", "a"), auto.key = list(lines = TRUE),
       ylab = "Rainfall (mm / month)")

## Clear days are most frequent in the mid latitudes.
xyplot(RainDays + CloudyDays + ClearDays ~ Latitude, EastAuClimate,
       type = c("p", "a"), auto.key = list(lines = TRUE),
       ylab = "Days per year")

---

Trellis Displays of Empirical CDF

Description

Conditional displays of Empirical Cumulative Distribution Functions

Usage

ecdfplot(x, data, ...)

## S3 method for class 'formula'
ecdfplot(x, data,
         prepanel = "prepanel.ecdfplot", 
         panel = "panel.ecdfplot",
         ylab,
         ...)
## S3 method for class 'numeric'
ecdfplot(x, data = NULL, xlab, ...)

prepanel.ecdfplot(x, f.value = NULL, ...)

panel.ecdfplot(x, f.value = NULL, type = "s",
               groups = NULL, qtype = 7,
               ref = TRUE,
               ...)

Arguments

x	For ecdfplot, x is the object on which method dispatch is carried out. For the "formula" method, x is a formula describing the form of conditioning plot, and has to be of the form ~x, where x is assumed to be a numeric vector. Further conditioning variables are allowed as usual. A similar interpretation holds for x in the "numeric" method as well as prepanel.ecdfplot and panel.ecdfplot.
data	For the "formula" method, a data frame containing values for any variables in the formula, as well as those in groups and subset if applicable.
prepanel, panel	panel and prepanel function used to create the display.
xlab, ylab	axis labels; typically a character string or an expression.
groups	a grouing variable of the same length as x. If specified, ECDF plots are computed for each subset defined by unique values of groups and the resulting functions superposed within each panel.
f.value, qtype	Defines how quantiles are calculated. See panel.qqmath.
ref	logical, whether a reference line should be drawn at 0 and 1
type	how the plot is rendered; see panel.xyplot
...	extra arguments, passed on as appropriate. Standard lattice arguments as well as arguments to panel.ecdfplot can be supplied directly in the high level ecdfplot call.

Value

ecdfplot produces 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.

Author(s)

Deepayan Sarkar [email protected]

See Also

qqmath for Quantile plots which are more generally useful, especially when comparing with a theoretical distribution other than uniform. An ECDF plot is essentially a transposed version (i.e., with axes switched) of a uniform quantile plot.

Examples

data(singer, package = "lattice")
ecdfplot(~height | voice.part, data = singer)

---

A ggplot2-like theme for Lattice

Description

A theme for Lattice based on some of the default styles used in the ggplot2 package by Hadley Wickham. Specifically, parts of the functions scale_colour_hue, scale_colour_gradient and theme_gray were copied. Although superficially similar, the implementation here lacks much of the flexibility of the ggplot2 functions: see http://had.co.nz/ggplot2/.

Usage

ggplot2like(..., n = 6, h = c(0,360) + 15, l = 65, c = 100,
            h.start = 0, direction = 1,
            low = "#3B4FB8", high = "#B71B1A", space = "rgb")

ggplot2like.opts()

axis.grid(side = c("top", "bottom", "left", "right"),
          ..., ticks = c("default", "yes", "no"),
          scales, components, line.col)

Arguments

...	further arguments passed on to simpleTheme to over-ride defaults.
n	number of superpose styles to generate, with equally spaced hues.
h, c, l, h.start, direction	range of hues, starting hue and direction to generate a discrete colour sequence with hcl.
low, high, space	extreme colors to interpolate with colorRampPalette for a continuous color scale.
side, ticks, scales, components, line.col	see axis.default. Typically axis.grid is not called directly so these should not be needed.

Value

ggplot2like() produces a list of settings which can be passed as the par.settings argument to a high-level Lattice plot, or to trellis.par.set. ggplot2like.opts() produces a list which can be passed as the lattice.options argument to a high-level Lattice plot, or to lattice.options.

Author(s)

Felix Andrews [email protected]; copied and adapted from ggplot2 by Hadley Wickham.

See Also

the ggplot2 package: http://had.co.nz/ggplot2/.

custom.theme, scale.components

Examples

set.seed(0)

## basic theme does not include white grid lines
xyplot(exp(1:10) ~ 1:10, type = "b", 
    par.settings = ggplot2like())

## add lines for axis ticks with custom axis function
xyplot(exp(1:10) ~ 1:10, type = "b", 
    par.settings = ggplot2like(), axis = axis.grid)
    
## this can be used together with scale.components
## (minor lines only visible on devices supporting translucency)
xyplot(exp(rnorm(500)) ~ rnorm(500),
    scales = list(y = list(log = TRUE)),
    yscale.components = yscale.components.log10ticks,
    par.settings = ggplot2like(), axis = axis.grid)

## ggplotlike.opts() specifies axis = axis.grid as well as
## xscale.components.subticks / yscale.components.subticks

xyg <- make.groups(
    "group one" = rnorm(80, 1),
    "group two" = rnorm(80, 5),
    "group three" = rnorm(80, 2))
xyg$x <- rev(xyg$data)

## group styles: specify number of equi-spaced hues
xyplot(data ~ x, xyg, groups = which, auto.key = TRUE, 
    par.settings = ggplot2like(n = 3),
    lattice.options = ggplot2like.opts()) +
  glayer(panel.smoother(...))

## or set it as the default:
opar <- trellis.par.get()
trellis.par.set(ggplot2like(n = 4, h.start = 180))
oopt <- lattice.options(ggplot2like.opts())

bwplot(voice.part ~ height, data = singer)

histogram(rnorm(100))

barchart(Titanic[,,,"No"], main = "Titanic deaths",
    layout = c(1, 2), auto.key = list(columns = 2))

## reset
trellis.par.set(opar)
lattice.options(oopt)

## axis.grid and scale.components.subticks can be used alone:
## (again, lines for minor ticks need transculency-support to show up)
xyplot(exp(1:10) ~ 1:10, type = "b", 
    lattice.options = ggplot2like.opts(),
    par.settings = list(axis.line = list(col = NA),
        reference.line = list(col = "grey")),
    scales = list(tck = c(0,0)))

---

Flow cytometry data from five samples from a patient

Description

Flow cytometry data from blood samples taken from a Leukemia patient before and after allogenic bone marrow transplant. The data spans five visits.

Usage

data(gvhd10)

Format

A data frame with 113896 observations on the following 8 variables.

FSC.H

forward scatter height values

SSC.H

side scatter height values

FL1.H

intensity (height) in the FL1 channel

FL2.H

intensity (height) in the FL2 channel

FL3.H

intensity (height) in the FL3 channel

FL2.A

intensity (area) in the FL2 channel

FL4.H

intensity (height) in the FL4 channel

Days

a factor with levels -6 0 6 13 20 27 34

Source

https://web.archive.org/web/20070427103026/http://www.ficcs.org/software.html#Data_Files

References

Brinkman, R.R., et al. (2007). High-Content Flow Cytometry and Temporal Data Analysis for Defining a Cellular Signature of Graft-Versus-Host Disease. Biology of Blood and Marrow Transplantation 13–6

Examples

## Figure 3.4 from Sarkar (2008)
data(gvhd10)
histogram(~log2(FSC.H) | Days, gvhd10, xlab = "log Forward Scatter",
          type = "density", nint = 50, layout = c(2, 4))

---

Plot many time series in parallel

Description

Plot many time series in parallel by cutting the y range into segments and overplotting them with color representing the magnitude and direction of deviation.

Usage

horizonplot(x, data, ...)

## Default S3 method:
horizonplot(x, data = NULL, ...,
            nbands = 3L,
            horizonscale = NA,
            origin = function(y) na.omit(y)[1],
            colorkey = FALSE, legend = NULL,
            panel = panel.horizonplot,
            prepanel = prepanel.horizonplot,
            col.regions = hcl.colors(2 * nbands, palette="RdYlBu"),
            strip = FALSE, strip.left = TRUE,
            par.strip.text = list(cex = 0.6),
            colorkey.digits = 3,
            layout = c(1, NA),
            groups = NULL,
            default.scales =
              list(y = list(relation = "free", axs = "i", 
                            draw = FALSE, tick.number = 2)))

panel.horizonplot(x, y, ..., border = NA,
                  nbands = 3L,
                  col.regions = hcl.colors(2 * nbands, palette="RdYlBu"),
                  origin)

prepanel.horizonplot(x, y, ..., horizonscale = NA,
                     nbands = 3L,
                     origin = function(y) na.omit(y)[1])

Arguments

x, y	Argument on which argument dispatch is carried out. Typically this will be a multivariate time series. In the panel and prepanel functions, these are the data coordinates.
data	Not used (at least, not used by xyplot.ts).
...	further arguments. Arguments to xyplot as well as to the default panel function panel.horizonplot can be supplied directly to horizonplot. In typical usage, the method of xyplot called will be xyplot.ts.
nbands	Integer giving the number of discrete color bands used (for both negative and positive deviations from the origin).
horizonscale	the scale of each color segment. There are 3 positive segments and 3 negative segments. If this is a given as a number then all panels will have comparable distances, though not necessarily the same actual values (similar in concept to scales$relation = "sliced"). If NA, as it is by default, then the scale is chosen in each panel to cover the range of the data (unless overridden by ylim); see Details.
origin	the baseline y value for the first (positive) segment (i.e. the value at which red changes to blue). This can be a number, which is then fixed across all panels, or it can be a function, which is evaluated with the y values in each panel. The default is the first non-missing y value in each panel. See the Details section.
colorkey, legend	if colorkey = TRUE a suitable color scale bar is constructed using the values of origin and horizonscale. Further options can be passed to colorkey in list form, as with levelplot.
panel	function to render the graphic given the data. This is the function that actually implements the display.
prepanel	function determining range of the data rectangle from data to be used in a panel.
col.regions	color scale, with at least 6 colors. This should be a divergent color scale (typically with white as the central color).
strip, strip.left	by default strips are only drawn on the left, to save space.
par.strip.text	graphical parameters for the strip text; see xyplot. One notable argument here is lines, allowing multi-line text.
colorkey.digits	digits for rounding values in colorkey labels.
layout	Numeric vector of length 2 (or 3) specifying number of columns and rows (and pages) in the plot. The default is to have one column and as many rows as there are panels.
default.scales	sets default values of scales; leave this alone, pass scales instead.
groups	not applicable to this type of plot.
border	border color for the filled polygons, defaults to no border.

Details

This function draws time series as filled areas, with modifications to effectively visualise many time series in parallel. Data that would be drawn off the top of each panel is redrawn from the bottom of the panel in a darker color. Values below the origin are inverted and drawn in the opposite color. There are up to three shades (typically in blue) for data above the baseline and up to three shades (typically in red) for data below the baseline. See the article referenced below for an introduction to Horizon plots.

There are three different cases of using this function:

1. horizonscale unspecified (default case): then each panel will have different scales, and the colors represent deviations from the origin up to the maximum deviation from the origin in that panel. If origin is specified then that will be constant across panels; otherwise it defaults to the initial value.

2. horizonscale specified but origin unspecified: the origin defaults to the initial value in each panel, and colors represent deviations from it in steps of horizonscale (up to 3 steps each way).

3. both horizonscale and origin specified: each panel will have the same scales, and colors represent fixed ranges of values.

In each of these cases the colorkey is labelled slightly differently (see examples).

Value

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.

Warning

Note that the y scale in each panel defines the actual origin and scale used. The origin and horizonscale arguments are only used in the prepanel function to choose an appropriate y scale. The ylim argument therefore over-rides origin and horizonscale. This also implies that choices of scales$y$relation other than "free" may have unexpected effects, particularly "sliced", as these change the y limits from those requested by the prepanel function.

Author(s)

Felix Andrews [email protected]

References

Stephen Few (2008). Time on the Horizon. Visual Business Intelligence Newsletter, June/July 2008 https://www.perceptualedge.com/articles/visual_business_intelligence/time_on_the_horizon.pdf

See Also

Lattice, xyplot.ts, panel.xyarea

Examples

## generate a random time series object with 12 columns
set.seed(1)
dat <- ts(matrix(cumsum(rnorm(200 * 12)), ncol = 12))
colnames(dat) <- paste("series", LETTERS[1:12])

## show simple line plot first, for reference.
xyplot(dat, scales = list(y = "same"))

## these layers show scale and origin in each panel...
infolayers <-
  layer(panel.scaleArrow(x = 0.99, digits = 1, col = "grey",
                         srt = 90, cex = 0.7)) +
  layer(lim <- current.panel.limits(),
    panel.text(lim$x[1], lim$y[1], round(lim$y[1],1), font = 2,
        cex = 0.7, adj = c(-0.5,-0.5), col = "#9FC8DC"))

## Case 1: each panel has a different origin and scale:
## ('origin' default is the first data value in each series).
horizonplot(dat, layout = c(1,12), colorkey = TRUE) +
  infolayers
 
## Case 2: fixed scale but different origin (baseline):
## (similar in concept to scales = "sliced")
horizonplot(dat, layout = c(1,12), horizonscale = 10, colorkey = TRUE) +
  infolayers

## Case 3: fixed scale and constant origin (all same scales):
horizonplot(dat, layout = c(1,12), origin = 0, horizonscale = 10, colorkey = TRUE) +
  infolayers

## same effect using ylim (but colorkey does not know limits):
horizonplot(dat, layout = c(1,12), ylim = c(0, 10), colorkey = TRUE) +
  infolayers

## same scales with full coverage of color scale:
horizonplot(dat, layout = c(1,12), origin = 0,
            scales = list(y = list(relation = "same")),
            colorkey = TRUE, colorkey.digits = 1) +
  infolayers


## use ylab rather than strip.left, for readability.
## also shade any times with missing data values.
horizonplot(dat, horizonscale = 10, colorkey = TRUE,
            layout = c(1,12), strip.left = FALSE,
            ylab = list(rev(colnames(dat)), rot = 0, cex = 0.7)) +
  layer_(panel.fill(col = "gray90"), panel.xblocks(..., col = "white"))


## illustration of the cut points used in the following plot
xyplot(EuStockMarkets, scales = list(y = "same"),
  panel = function(x, y, ...) {
    col <-
    c("#B41414","#E03231","#F7A99C","#9FC8DC","#468CC8","#0165B3")
    for (i in c(-3:-1, 2:0)) {
      if (i >= 0)
        yi <- pmax(4000, pmin(y, 4000 + 1000 * (i+1)))
      if (i < 0)
        yi <- pmin(4000, pmax(y, 4000 + 1000 * i))
      panel.xyarea(x, yi, origin = 4000,
        col = col[i+4], border = NA)
    }
    panel.lines(x, y)
    panel.abline(h = 4000, lty = 2)
  })

## compare with previous plot
horizonplot(EuStockMarkets, colorkey = TRUE,
            origin = 4000, horizonscale = 1000) +
  infolayers

## a cut-and-stack plot; use constant y scales!
horizonplot(sunspots, cut = list(n = 23, overlap = 0),
  scales = list(draw = FALSE, y = list(relation = "same")),
  origin = 100, colorkey = TRUE,
  strip.left = FALSE, layout = c(1,23)) +
layer(grid::grid.text(round(x[1]), x = 0, just = "left"))

---

Add layers to a lattice plot, optionally using a new data source

Description

A mechanism to add new layers to a trellis object, optionally using a new data source. This is an alternative to modifying the panel function. Note the non-standard evaluation in layer().

Usage

layer(..., data, magicdots, exclude,
      packets, rows, columns, groups,
      style, force, theme, under, superpose)

layer_(...)
glayer(...)
glayer_(...)

## S3 method for class 'trellis'
object + lay

drawLayer(lay, panelArgs = trellis.panelArgs())

flattenPanel(object)

Arguments

...	expressions as they would appear in a panel function. These can refer to the panel function arguments (such as x, y and subscripts), and also to any named objects passed in through the data argument. The calls can also include the special argument “...”; in the default case of magicdots = TRUE, only those arguments which are not already named in a call are passed on through “...”. Otherwise, “...” simply represents all panel function arguments. See Details, below.
data	optional. A named list containing objects needed when evaluating (drawing) the layer.
magicdots, exclude	if magicdots = TRUE, the default, any reference to “...” in the layer expressions will only pass on those arguments from the panel function which are not named in the call (thus avoiding duplicate argument errors). If the first argument in a call is not named, it is assumed to be named "x", and if the second argument is not named it is assumed to be named "y". Furthermore, any argument names given in exclude will not be passed on through “...”.
packets, rows, columns, groups	restricts the layer to draw only in specified packets (which refer to individual panels, but are independent of their layout), or rows or columns of the trellis layout (trellis.currentLayout). For group layers (using glayer or superpose = TRUE), the groups can be restricted also, by specifying group numbers (or group values, as character strings). Negative values exclude the given items.
style	style index of the layer, used only to set lattice graphical parameters (same effect as in grouped displays). Note that this will use the theme settings in effect in the existing plot, which may or may not be what is desired. It may be necessary to use force = TRUE to escape from the plot's settings and use the current theme.
force	force = TRUE is just a shorthand for theme = trellis.par.get(), which is useful for over-riding the theme settings in effect in an existing plot. For instance, if the original plot specified par.settings = simpleTheme(col = "red") then the theme settings in effect will be entirely red. Use force = TRUE to reset the current theme for this layer, or use theme directly.
theme	a style specification to be passed to trellis.par.set which has effect only while drawing the layer. One can pass a whole theme specification list, such as theme = custom.theme(), or a more specific list, such as theme = simpleTheme(col = "red").
under	whether the layer should be drawn before the existing panel function. This defaults to TRUE in the convenience functions layer_() and glayer_().
superpose	if TRUE, the layer will be drawn once for each level of any groups in the plot, using panel.superpose. This defaults to TRUE in the convenience functions glayer() and glayer_().
object	a trellis object.
lay	a layer object.
panelArgs	list of arguments to the panel function.

Details

The layer mechanism is a method for augmenting a panel function. It allows expressions to be added to the panel function without knowing what the original panel function was. In this way it can be useful for convenient augmentation of trellis plots.

Note that the evaluation used in layer is non-standard, and can be confusing at first: you typically refer to variables as if inside the panel function (x, y, etc); you can usually refer to objects which exist in the global environment (workspace), but it is safer to pass them in by name in the data argument to layer. (And this should not to be confused with the data argument to the original xyplot.)

A simple example is adding a reference line to each panel: layer(panel.refline(h = 0)). Note that the expressions are quoted, so if you have local variables they will need to be either accessible globally, or passed in via the data argument. For example:

layer(panel.refline(h = myVal)) ## if myVal is global

layer(panel.refline(h = h), data = list(h = myVal))

Another non-standard aspect is that the special argument “...” will, by default, only pass through those argument not already named. For example, this will over-ride the x argument and pass on the remaining arguments:

layer(panel.xyplot(x = jitter(x), ...))

The first un-named argument is assumed to be "x", so that is the same as

layer(panel.xyplot(jitter(x), ...))

The layer mechanism should probably still be considered experimental.

drawLayer() actually draws the given layer object, applying the panel specification, style settings and so on. It should only be called while a panel is in focus.

The flattenPanel function will construct a human-readable function incorporating code from all layers (and the original panel function). Note that this does not return a usable function, as it lacks the correct argument list and ignores any extra data sources that layers might use. It is intended be edited manually.

Value

a layer object is defined as a list of expression objects, each of which may have a set of attributes. The result of "adding" a layer to a trellis object (+.trellis) is the updated trellis object.

Author(s)

Felix Andrews [email protected]

See Also

update.trellis, as.layer for overlaying entire plots

Examples

foo <- xyplot(ozone ~ wind, environmental)
foo

## overlay reference lines
foo <- foo + layer(panel.abline(h = 0)) +
             layer(panel.lmline(x, y, lty = 2))

## underlay a flat color
foo <- foo + layer(panel.fill(grey(.95)), under = TRUE)
foo

## layers can access the panel function arguments
foo <- foo + layer({ ok <- (y>100);
            panel.text(x[ok], y[ok], y[ok], pos = 1) })
foo

## over-ride arguments by name
foo <- foo +
  layer(panel.xyplot(y = ave(y, x, FUN = max), type = "a", ...))
foo

## see a sketch of the complete panel function
flattenPanel(foo)


## group layers, drawn for each group in each panel
dotplot(VADeaths, type = "o") +
  glayer(ltext(x[5], y[5], group.value, srt = 40))

## a quick way to print out the panel.groups arguments:
dotplot(VADeaths, type = "o") + glayer(str(list(...)))


## layers with superposed styles
xyplot(ozone ~ wind | equal.count(temperature, 2),
       data = environmental) +
   layer(panel.loess(x, y, span = 0.5), style = 1) +
   layer(panel.loess(x, y, span = 1.0), style = 2) +
   layer(panel.key(c("span = 0.5", "span = 1.0"), corner = c(1,.98),
                   lines = TRUE, points = FALSE), packets = 1)

## note that styles come from the settings in effect in the plot,
## which is not always what you want:
xyplot(1:10 ~ 1:10, type = "b", par.settings = simpleTheme(col = "red")) +
  layer(panel.lines(x = jitter(x, 2), ...)) +  ## drawn in red
  layer(panel.lines(x = jitter(x, 2), ...), force = TRUE)  ## reset theme


## using other variables from the original `data` object
## NOTE: need subscripts = TRUE in original call!
zoip <- xyplot(wind ~ temperature | equal.count(radiation, 2),
   data = environmental, subscripts = TRUE)
zoip + layer(panel.points(..., pch = 19,
             col = grey(1 - ozone[subscripts] / max(ozone))),
       data = environmental)


## restrict drawing to specified panels
barchart(yield ~ variety | site, data = barley,
         groups = year, layout = c(1,6), as.table = TRUE,
         scales = list(x = list(rot = 45))) +
layer(ltext(tapply(y, x, max), lab = abbreviate(levels(x)),
      pos = 3), rows = 1)


## example of a new data source
qua <- xyplot(lat ~ long | cut(depth, 2), quakes,
    aspect = "iso", pch = ".", cex = 2)
qua
## add layer showing distance from Auckland
newdat <- with(quakes, expand.grid(
            gridlat = seq(min(lat), max(lat), length = 60),
            gridlon = seq(min(long), max(long), length = 60)))
newdat$dist <- with(newdat, sqrt((gridlat - -36.87)^2 +
                                 (gridlon - 174.75)^2))
qua + layer_(panel.contourplot(x = gridlon, y = gridlat, z = dist,
   contour = TRUE, subscripts = TRUE), data = newdat)

---

Trellis displays on Maps a.k.a. Choropleth maps

Description

Produces Trellis displays of numeric (and eventually categorical) data on a map. This is largely meant as a demonstration, and users looking for serious map drawing capabilities should look elsewhere (see below).

Usage

mapplot(x, data, ...)

## S3 method for class 'formula'
mapplot(x, data, map, outer = TRUE,
        prepanel = prepanel.mapplot,
        panel = panel.mapplot,
        aspect = "iso",
        legend = NULL,
        breaks, cuts = 30,
        colramp = colorRampPalette(hcl.colors(n = 11, palette = "Spectral")),
        colorkey = TRUE,
        ...)

prepanel.mapplot(x, y, map, ...)
panel.mapplot(x, y, map, breaks, colramp, exact = FALSE, lwd = 0.5, ...)

Arguments

x, y	For mapplot, an object on which method dispatch is carried out. For the formula method, a formula of the form y ~ x, with additional conditioning variables as desired. The extended form of conditioning using y ~ x1 + x2 etc. is also allowed. The formula might be interpreted as in a dot plot, except that y is taken to be the names of geographical units in map. Suitable subsets (packets) of x and y are passed to the prepanel and panel functions.
data	A data source where names in the formula are evaluated
map	An object of class "map" (package maps), containing boundary information. The names of the geographical units must match the y variable in the formula.

The remaining arguments are standard lattice arguments, relevant here mostly because they have different defaults than usual:

outer	Logical flag specifying how variables separated by + in the formula are interpreted. It is not advisable to change the default.
prepanel	The prepanel function.
panel	The panel function.
aspect	The aspect ratio.
breaks, cuts, colramp	controls conversion of numeric x values to a false color. colramp should be a function that produces colors (such as cm.colors). If it is NULL, colors are taken from trellis.par.get("regions").
exact	the default exact = FALSE allows the given y values to match sub-regions of map, i.e. region names with a qualifier following ":", like "michigan:north", "michigan:south". These will both match a y value of "Michigan".
legend, colorkey	controls legends; usually just a color key giving the association between numeric values of x and color.
lwd	line width
...	Further arguments passed on to the underlying engine. See xyplot for details.

Value

An object of class "trellis".

Note

This function is meant to demonstrate how maps can be incorporated in a Trellis display. Users seriously interested in geographical data should consider using software written by people who know what they are doing.

Author(s)

Deepayan Sarkar

References

https://en.wikipedia.org/wiki/Choropleth_map

See Also

Lattice

Examples

## Requires the 'maps' and 'mapproj' packages:

if (require(maps) && require(mapproj)) {

    ## Note: Alaska, Hawaii and others are not included in county map;
    ## this generates warnings with both USCancerRates and ancestry.

    data(USCancerRates)

    suppressWarnings(print(
        mapplot(rownames(USCancerRates) ~ log(rate.male) + log(rate.female),
                data = USCancerRates,
                map = map("county", plot = FALSE, fill = TRUE,
                          projection = "mercator"))
    ))

    suppressWarnings(print(
        mapplot(rownames(USCancerRates) ~ log(rate.male) + log(rate.female),
                data = USCancerRates,
                map = map("county", plot = FALSE, fill = TRUE,
                          projection = "tetra"),
                scales = list(draw = FALSE))
    ))

    data(ancestry)

    county.map <- 
        map('county', plot = FALSE, fill = TRUE, 
            projection = "azequalarea")

    ## set a sequential color palette as current theme, and use it
    opar <- trellis.par.get()
    trellis.par.set(custom.theme(region = rev(hcl.colors(9, "Purp")),
                                 alpha.line = 0.5))
    suppressWarnings(print(
        mapplot(county ~ log10(population), ancestry, map = county.map,
                colramp = NULL, border = "transparent")
    ))
    trellis.par.set(opar)
}

## Not run: 

## this may take a while (should get better area records)

if (require(maps) && require(mapproj)) {

    county.areas <- 
        area.map(county.map, regions = county.map$names, sqmi = FALSE)
    
    ancestry$density <- 
        with(ancestry, population / county.areas[as.character(county)])

    mapplot(county ~ log(density), ancestry,
            map = county.map, border = NA,
            colramp = colorRampPalette(c("white", "black")))

}

## End(Not run)

---

Display marginal distributions

Description

Display marginal distributions of several variables, which may be numeric and/or categorical, on one plot.

Usage

marginal.plot(x,
              data = NULL,
              groups = NULL,
              reorder = !is.table(x),
              plot.points = FALSE,
              ref = TRUE, cut = 0,
              origin = 0, 
              xlab = NULL, ylab = NULL,
              type = c("p", if (is.null(groups)) "h"),
              ...,
              subset = TRUE,
              as.table = TRUE,
              subscripts = TRUE,
              default.scales = list(
                relation = "free",
                abbreviate = TRUE, minlength = 5,
                rot = 30, cex = 0.75, tick.number = 3,
                y = list(draw = FALSE)),
             layout = NULL,
             lattice.options = list(
               layout.heights = list(
                 axis.xlab.padding = list(x = 0),
                 xlab.key.padding = list(x = 0))))

Arguments

x	a data frame or table, or a formula of which the first term is a data frame or table. Otherwise coerced with as.data.frame.
data	an optional data source in which groups and subset may be be evaluated.
groups	term, to be evaluated in data, that is used as a grouping variable.
reorder	whether to reorder factor variables by frequency.
subset	data subset expression, evaluated in data.
plot.points, ref, cut	passed to panel.densityplot.
origin, type	passed to panel.dotplot.
xlab, ylab, as.table, subscripts	see xyplot.
default.scales, layout, lattice.options	see xyplot.
...	passed to panel.densityplot and/or panel.dotplot.

Details

In the case of mixed numeric and categorical variables, the trellis objects from dotplot() and densityplot() are merged.

Value

a trellis object.

Author(s)

Felix Andrews [email protected]

See Also

panel.dotplot, panel.densityplot

Examples

enviro <- environmental
## make an ordered factor (so it will not be reordered)
enviro$smell <- cut(enviro$ozone, breaks = c(0, 30, 50, Inf),
    labels = c("ok", "hmmm", "yuck"), ordered = TRUE)
marginal.plot(enviro)

## using groups
enviro$is.windy <- factor(enviro$wind > 10,
    levels = c(TRUE, FALSE), labels = c("windy", "calm"))
marginal.plot(enviro[,1:5], data = enviro, groups = is.windy,
    auto.key = list(lines = TRUE))

## support for tables
marginal.plot(Titanic)
## table with groups
marginal.plot(~ Titanic, data = Titanic, groups = Survived,
    type = "b", auto.key = list(title = "Survived?"))

---

Plot a smooth approximation of z over x and y.

Description

Plot a smooth approximation, using loess by default, of one variable (z) against two others (x and y).

This panel function should be used with a levelplot.

Usage

panel.2dsmoother(x, y, z, subscripts = TRUE,
    form = z ~ x * y, method = "loess", ...,
    args = list(), n = 100)

Arguments

x, y, z	data points. If these are missing, they will be looked for in the environment of form. So in many cases you can skip these if passing form. In fact, for convenience, the formula can be passed as the first argument (i.e. x).
form, method	the smoothing model is constructed (approximately) as method(form, data = list(x=x, y=y, z=z), {args}). See the Examples section for common choices.
subscripts	data indices for the current packet, as passed in by levelplot.
...	further arguments passed on to panel.levelplot.
args	a list of further arguments to the model function (method).
n	number of equi-spaced points along each of x and y on which to evaluate the smooth function.

Details

This should work with any model function that takes a formula argument, and has a predict method argument.

Author(s)

Felix Andrews [email protected]

See Also

loess, panel.smoother

Examples

set.seed(1)
xyz <- data.frame(x = rnorm(100), y = rnorm(100))
xyz$z <- with(xyz, x * y + rnorm(100, sd = 1))

levelplot(z ~ x * y, xyz, panel = panel.2dsmoother)

## showing data points on the same color scale
levelplot(z ~ x * y, xyz,
          panel = panel.levelplot.points, cex = 1.2) +
  layer_(panel.2dsmoother(..., n = 200))

## simple linear regression model
levelplot(z ~ x * y, xyz,
          panel = panel.levelplot.points) +
  layer_(panel.2dsmoother(..., method = "lm"))

## GAM smoother with smoothness by cross validation
if (require("mgcv"))
  levelplot(z ~ x * y, xyz, panel = panel.2dsmoother,
            form = z ~ s(x, y), method = "gam")

---

Miscellanous panel utilities for three dimensional Trellis Displays

Description

Miscellanous panel functions for use with three dimensional Lattice functions such as cloud and wireframe

Usage

panel.3dbars(x, y, z,
             rot.mat = diag(4), distance,
             xbase = 1, ybase = 1,
             xlim, xlim.scaled,
             ylim, ylim.scaled,
             zlim, zlim.scaled,
             zero.scaled,
             col = "black",
             lty = 1, lwd = 1,
             alpha,
             ...,
             col.facet = "white",
             alpha.facet = 1)


panel.3dpolygon(x, y, z, rot.mat = diag(4), distance,
                xlim.scaled,
                ylim.scaled,
                zlim.scaled,
                zero.scaled,
                col = "white",
                border = "black",
                font, fontface,
                ...)

panel.3dtext(x, y, z, labels = seq_along(x),
             rot.mat = diag(4), distance, ...)

Arguments

x, y, z	data to be plotted
rot.mat, distance	arguments controlling projection
labels	character or expression vectors to be uses as labels
xlim, ylim, zlim	limits in the original scale
xlim.scaled, ylim.scaled, zlim.scaled	limits after scaling
zero.scaled	the value of z = 0 after scaling
xbase, ybase	length of the sides of the bars (which are always centered on the x and y values). Can not be vectorized.
col, lty, lwd, alpha, border	Graphical parameters for the border lines. These can be vectors, in which case each component will be associated with one bar in panel.3dbars.
font, fontface	unused graphical parameters, present in the argument list only so that they can be captured and ignored
col.facet, alpha.facet	Graphical parameters for surfaces of the bars . These can be vectors, in which case each component will be associated with one bar.
...	extra arguments, passed on as appropriate.

Details

panel.3dbars and panel.3dpolygon are both suitable for use as (components of) the panel.3d.cloud argument of panel.cloud. The first one produces three dimensional bars, and the second one draws three dimensional polygons.

Author(s)

Deepayan Sarkar [email protected]

See Also

cloud, panel.cloud

Examples

library(lattice)

cloud(VADeaths, panel.3d.cloud = panel.3dbars,
      col.facet = "grey", xbase = 0.4, ybase = 0.4,
      screen = list(z = 40, x = -30))

cloud(VADeaths, panel.3d.cloud = panel.3dbars,
      xbase = 0.4, ybase = 0.4, zlim = c(0, max(VADeaths)),
      scales = list(arrows = FALSE, just = "right"), xlab = NULL, ylab = NULL,
      col.facet = level.colors(VADeaths, at = do.breaks(range(VADeaths), 20),
                               col.regions = terrain.colors,
                               colors = TRUE),
      colorkey = list(col = terrain.colors, at = do.breaks(range(VADeaths), 20)),
      screen = list(z = 40, x = -30))


cloud(as.table(prop.table(Titanic, margin = 1:3)[,,,2]),
      type = c("p", "h"),
      zlab = "Proportion\nSurvived",
      panel.3d.cloud = panel.3dbars,
      xbase = 0.4, ybase = 0.4,
      aspect = c(1, 0.3),
      scales = list(distance = 2),
      panel.aspect = 0.5)

---

Lattice panel function to fit and draw a confidence ellipsoid from bivariate data.

Description

A lattice panel function that computes and draws a confidence ellipsoid from bivariate data, possibly grouped by a third variable.

Usage

panel.ellipse(x, y, groups = NULL,
              level = 0.68, segments = 50, robust = FALSE,
              center.pch = 3, center.cex = 2, ...,
              type, pch, cex)

Arguments

x, y	Numeric vectors of same length giving the bivariate data. Non-numeric variables will be coerced to be numeric.
groups	Optional grouping variable.
level	Confidence level for the ellipse.
segments	Number of segments used to approximate the ellipse.
robust	Logical indicating whether a robust method should be used. If TRUE, the confidence ellipse is based on a bivariate t-distribution using the cov.trob function in the MASS package.
center.pch	Plotting character for the center (fitted mean). If NULL, the center will not be shown on the plot.
center.cex	Character expansion (size) multipler for the symbol indicating the center.
...	Further arguments, typically graphical parameters. Passed on to panel.xyplot.
type, pch, cex	Parameters that are ignored; these are present only to make sure they are not inadvertently passed on to panel.xyplot.

Author(s)

Deepayan Sarkar, extending code contributed by Michael Friendly.

Examples

xyplot(Sepal.Length ~ Petal.Length, groups=Species,
       data = iris, scales = "free",
       par.settings = list(superpose.symbol = list(pch=c(15:17)),
                           superpose.line = list(lwd=2, lty=1:3)),
       panel = function(x, y, ...) {
           panel.xyplot(x, y, ...)
           panel.ellipse(x, y, ...)
       },
       auto.key = list(x = .1, y = .8, corner = c(0, 0)))

## Without groups
xyplot(Sepal.Length ~ Petal.Length, 
       data = iris, scales = "free",
       par.settings = list(plot.symbol = list(cex = 1.1, pch=16)),
       panel = function(x, y, ...) {
           panel.xyplot(x, y, ...)
           panel.ellipse(x, y, lwd = 2, ...)
       },
       auto.key = list(x = .1, y = .8, corner = c(0, 0)))


## With conditioning
xyplot(Sepal.Length ~ Petal.Length | Species, 
       data = iris, scales = "free",
       par.settings = list(plot.symbol = list(cex = 1.1, pch=16)),
       layout=c(2,2),
       panel = function(x, y, ...) {
           panel.xyplot(x, y, ...)
           panel.ellipse(x, y, lwd = 2, ...)
       },
       auto.key = list(x = .6, y = .8, corner = c(0, 0)))


## Compare classical with robust 
xyplot(Sepal.Length ~ Petal.Length | Species, 
       data = iris, scales = "free",
       par.settings = list(plot.symbol = list(cex = 1.1, pch=16)),
       layout=c(2,2),
       panel = function(x, y, ...) {
           panel.xyplot(x, y, ...)
           panel.ellipse(x, y, lwd = 2, ...)
           panel.ellipse(x, y, lwd = 2, col="red", robust=TRUE,  ...)
       })

---

Draw a simple key inside a panel of a lattice plot.

Description

Draw a simpleKey inside a panel of a lattice plot.

Usage

panel.key(text, ..., corner = c(0, 1), x = corner[1], y = corner[2])

Arguments

text, ...	entries in the simpleKey.
corner, x, y	defines the position of the key within the panel viewport. These are given in normalised coordinates between 0 and 1. The two elements of corner specify the x and y positions respectively.

See Also

simpleKey, draw.key, xyplot

Examples

xyplot(ozone ~ wind | equal.count(temperature, 2),
       data = environmental) +
   layer(panel.loess(x, y, span = 0.5), style = 1) +
   layer(panel.loess(x, y, span = 1.0), style = 2) +
   layer(panel.key(c("span = 0.5", "span = 1.0"), corner = c(1,.98),
                   lines = TRUE, points = FALSE), packets = 1)

---

Draw a line with a label, by default its equation

Description

This is an extension of the panel functions panel.abline and panel.lmline to also draw a label on the line. The default label is the line equation, and optionally the R squared value of its fit to the data points.

Usage

panel.ablineq(a = NULL, b = 0,
              h = NULL, v = NULL,
              reg = NULL, coef = NULL,
              pos = if (rotate) 1 else NULL,
              offset = 0.5, adj = NULL,
              at = 0.5, x, y,
              rotate = FALSE, srt = 0,
              label = NULL,
              varNames = alist(y = y, x = x),
              varStyle = "italic",
              fontfamily = "serif",
              digits = 3,
              r.squared = FALSE, sep = ", ", sep.end = "",
              col, col.text, col.line,
              ..., reference = FALSE)

panel.lmlineq(x, y, ...)

Arguments

a, b, h, v, reg, coef	specification of the line. The simplest usage is to give a and b to describe the line y = a + b x. Horizontal or vertical lines can be specified as arguments h or v, respectively. The first argument (a) can also be a model object produced by lm. See panel.abline for more details.
pos, offset	passed on to panel.text. For pos: 1 = below, 2 = left, 3 = above, 4 = right, and the offset (in character widths) is applied.
adj	passed on to panel.text. c(0,0) = above right, c(1,0) = above left, c(0,1) = below right, c(1,1) = below left; offset does not apply when using adj.
fontfamily	passed on to panel.text.
at	position of the equation as a fractional distance along the line. This should be in the range 0 to 1. When a vertical line is drawn, this gives the vertical position of the equation.
x, y	position of the equation in native units. If given, this over-rides at. For panel.lmlineq this is the data, passed on as lm(y ~ x).
rotate, srt	set rotate = TRUE to align the equation with the line. This will over-ride srt, which otherwise gives the rotation angle. Note that the calculated angle depends on the current device size; this will be wrong if you change the device aspect ratio after plotting.
label	the text to draw along with the line. If specified, this will be used instead of an equation.
varNames	names to display for x and/or y. This should be a list like list(y = "Q", x = "X") or, for mathematical symbols, alist(y = (alpha + beta), x = sqrt(x[t])).
varStyle	the name of a plotmath function to wrap around the equation expression, or NULL. E.g. "bolditalic", "displaystyle".
digits	number of decimal places to show for coefficients in equation.
r.squared	the $R^2$ statistic to display along with the equation of a line. This can be given directly as a number, or TRUE, in which case the function expects a model object (typically lm) and extracts the $R^2$ statistic from it.
sep, sep.end	The $R^2$ (r.squared) value is separated from the equation by the string sep, and also sep.end is added to the end. For example: panel.ablineq(lm(y ~ x), r.squared = TRUE, sep = " (", sep.end = ")").
..., col, col.text, col.line	passed on to panel.abline and panel.text. Note that col applies to both text and line; col.text applies to the equation only, and col.line applies to line only.
reference	whether to draw the line in a "reference line" style, like that used for grid lines.

Details

The equation is constructed as an expression using plotmath.

Author(s)

Felix Andrews [email protected]

See Also

panel.abline, panel.text, lm, plotmath

Examples

set.seed(0)
xsim <- rnorm(50, mean = 3)
ysim <- (0 + 2 * xsim) * (1 + rnorm(50, sd = 0.3))

## basic use as a panel function
xyplot(ysim ~ xsim, panel = function(x, y, ...) {
  panel.xyplot(x, y, ...)
  panel.ablineq(a = 0, b = 2, adj = c(0,1))
  panel.lmlineq(x, y, adj = c(1,0), lty = 2,
                col.line = "grey", digits = 1)
})

## using layers:
xyplot(ysim^2 ~ xsim) +
  layer(panel.ablineq(lm(y ~ x, subset = x <= 3),
    varNames = alist(y = y^2, x = x[x <= 3]), pos = 4))

## rotated equation (depends on device aspect at plotting time)
xyplot(ysim ~ xsim) +
  layer(panel.ablineq(lm(y ~ x), rotate = TRUE, at = 0.8))

## horizontal and vertical lines
xyplot(ysim ~ xsim) +
  layer(panel.ablineq(v = 3, pos = 4, at = 0.1, lty = 2,
                      label = "3.0 (critical value)")) +
  layer(panel.ablineq(h = mean(ysim), pos = 3, at = 0.15, lty = 2,
                      varNames = alist(y = plain(mean)(y))))

## using layer styles, r.squared
xyplot(ysim ~ xsim) +
  layer(panel.ablineq(lm(y ~ x), r.sq = TRUE,
                      at = 0.4, adj=0:1), style = 1) +
  layer(panel.ablineq(lm(y ~ x + 0), r.sq = TRUE,
                      at = 0.6, adj=0:1), style = 2)

## alternative placement of equations
xyplot(ysim ~ xsim) +
  layer(panel.ablineq(lm(y ~ x), r.sq = TRUE, rot = TRUE,
                      at = 0.8, pos = 3), style = 1) +
  layer(panel.ablineq(lm(y ~ x + 0), r.sq = TRUE, rot = TRUE,
                      at = 0.8, pos = 1), style = 2)

update(trellis.last.object(),
  auto.key = list(text = c("intercept", "no intercept"),
                  points = FALSE, lines = TRUE))

---

Approximate distribution in qqmath but keep points on tails.

Description

Panel function for qqmath to reduce the number of points plotted by sampling along the specified distribution. The usual method for such sampling is to use the f.value argument to panel.qqmath. However, this panel function differs in two ways: (1) a specified number of data points are retained (not interpolated) on each tail of the distribution. (2) the sampling is evenly spaced along the specified distribution automatically (whereas f.value = ppoints(100) is evenly spaced along the uniform distribution only).

This function is deprecated as of lattice 0.18-4 (available for R 2.11.0). Use the tails.n argument of panel.qqmath instead.

Usage

panel.qqmath.tails(x, f.value = NULL, distribution = qnorm,
                    groups = NULL, ..., approx.n = 100, tails.n = 10)

Arguments

x, f.value, distribution, groups	see panel.qqmath.
...	further arguments passed on to panel.xyplot.
approx.n	number of points to use in approximating the distribution. Points will be equally spaced in the distribution space.
tails.n	number of points to retain (untouched) at both the high and low tails.

Author(s)

Felix Andrews [email protected]

See Also

panel.qqmath which should be used instead (as of lattice 0.18-4).

Examples

## see ?panel.qqmath

---

Plot a quantile regression line with standard error bounds.

Description

Plot a quantile regression line with standard error bounds, using the quantreg package. This is based on the stat_quantile function from ggplot2.

Usage

panel.quantile(x, y, form = y ~ x, method = "rq", ...,
    tau = 0.5, ci = FALSE, ci.type = "default", level = 0.95,
    n = 100, col = plot.line$col, col.se = col,
    lty = plot.line$lty, lwd = plot.line$lwd,
    alpha = plot.line$alpha, alpha.se = 0.25, border = NA,
    superpose = FALSE,
    ## ignored: ##
    subscripts, group.number, group.value,
    type, col.line, col.symbol, fill,
    pch, cex, font, fontface, fontfamily)

Arguments

x, y	data points. If these are missing, they will be looked for in the environment of form. So in many cases you can skip these if passing form. In fact, for convenience, the formula can be passed as the first argument (i.e. x).
form, method	Formula and the name of a modeling function (as a character string). The model is constructed (approximately) as method(form, tau = tau, data = list(x=x, y=y), ...). Currently, method is expected to be either "rq" or "rqss", and for these the corresponding functions in the quantreg package is used. In principle, any other function that supports the same interface can also be specified by name.
...	further arguments passed on to the model function (method), typically rq.
tau	p values for the quantiles to estimate. Note: only one value for tau can be specified if estimating confidence intervals with ci.
ci, ci.type, level	estimate a confidence interval at level level using the method ci.type; see predict.rq.
n	number of equi-spaced points on which to evaluate the function.
col, col.se, lty, lwd, alpha, alpha.se, border	graphical parameters. col and alpha apply to the line(s), while col.se and alpha.se apply to the shaded ci region.
superpose	if TRUE, plot each quantile line (tau) in a different style (using trellis.par.get("superpose.line")).
subscripts, group.number, group.value, type, col.line, col.symbol, fill, pch, cex, font, fontface, fontfamily	ignored.

Details

It is recommended to look at vignette("rq", package="quantreg").

Author(s)

Felix Andrews [email protected]

Based on stat_quantile by Hadley Wickham.

See Also

rq, panel.smoother, stat_quantile

Examples

## library("quantreg")

set.seed(1)
xy <- data.frame(x = runif(100), y = rt(100, df = 5))
xyplot(y ~ x, xy) +
    layer(panel.quantile(x, y, tau = c(.95, .5, .05)))

if (require("splines")) {
    xyplot(y ~ x, xy) +
        layer(panel.quantile(y ~ ns(x, 3), tau = 0.9))

    xyplot(y ~ x, xy) +
        layer(panel.quantile(y ~ ns(x, 3), tau = 0.9, ci = TRUE))
}

xyplot(y ~ x, xy) +
    layer(panel.quantile(x, y, tau = c(.5, .9, .1), superpose = TRUE))

update(trellis.last.object(),
       auto.key = list(text = paste(c(50,90,10), "% quantile"),
                  points = FALSE, lines = TRUE))

xyplot(y ~ x, xy) +
    layer(panel.quantile(y ~ qss(x, lambda=1), method = "rqss"))

---

Draw a scale bar as an arrow, labelled with its length in plot units.

Description

Draw a scale bar as an arrow, labelled with its length in plot units.

Usage

panel.scaleArrow(x = unit(0:1, "npc"), y = unit(0:1, "npc"),
                 default.units = "npc",
                 digits = 0, append = "", label = NULL,
                 angle = 30, length = 0.5, unit = "char",
                 type = "open", ends = "both",
                 ...,
                 col = add.line$col, fill = col, alpha = add.line$alpha,
                 lty = add.line$lty, lwd = add.line$lwd,
                 col.text = add.text$col, alpha.text = add.text$alpha)

Arguments

x, y, default.units	coordinates of the line ends as grid units or otherwise interpreted in default.units.
digits	number of decimal places to keep for the distance measure.
append	a string to append to the distance for the label.
label	label to place on the mid point of the scale, over-riding the default.
angle, length, unit, type, ends	specification of the arrow style; see panel.arrows.
...	further arguments passed to panel.text. You will need at least the pos or adj arguments.
col, fill, alpha, lty, lwd	graphical parameters relevant to the line.
col.text, alpha.text	graphical parameters relevant to the text label. Others like cex and font can be passed though ....

Author(s)

Felix Andrews [email protected]

See Also

panel.abline, grid.text

Examples

xyplot(EuStockMarkets) +
  layer(panel.scaleArrow(x = 0.99, append = " units",
          col = "grey", srt = 90, cex = 0.8))

---

Default prepanel and panel functions for segplot

Description

Draws line segments or rectangles. Mainly intended to be used in conjunction with the segplot function.

Usage

prepanel.segplot(x, y, z, subscripts, horizontal = TRUE, ...)

panel.segplot(x, y, z, level = NULL, subscripts, 
              at,
              draw.bands = is.factor(z),
              col, alpha, 
              lty, lwd,
              border,
              col.symbol = col, alpha.symbol = alpha,
              col.regions = regions$col,
              band.height = 0.6,
              horizontal = TRUE, 
              ...,
              segments.fun = panel.segments,
              centers = NULL,
              pch = 16)

Arguments

x, y, z	Vectors corresponding to x1, x2 and y respectively in the segplot formula. The names are different for compatibility with panel.levelplot. These are all the original vectors in data, not subsetted for particular panels.
level	optional vector controlling color of segments
centers	optional vector of ‘centers’ of the segments. If specified, points will be plotted at these y-locations.
pch	plotting character used for centers.
subscripts	integer subscript to be used as an indexing vector for x, y, z and level, giving the packet for the current panel.
horizontal	logical, whether the segments are to be drawn horizontally (the default) or vertically. This essentially swaps the role of the x- and y-axes in each panel.
at	values of level where color code changes
draw.bands	logical, whether to draw rectangles instead of lines
col, alpha, lty, lwd, border	Graphical parameters for the segment. Defaults to parameter settings for "plot.line" or "plot.polygon" for segments and rectangles respectively. col is overridden by col.regions if level is not null.
col.symbol, alpha.symbol	Graphical parameters for the point if centers are plotted. Defaults to the corresponding parameters for the segment.
col.regions	vector of colors as in levelplot
band.height	height of rectangles (applicable if draw.bands is TRUE
...	Other arguments, passed on to panel.rect (when draw.bands=TRUE), segments.fun (otherwise), panel.points (if centers is not NULL), etc. as appropriate.
segments.fun	function used to plot segments when draw.bands is FALSE. The default is to use panel.segments, but panel.arrows is a useful alternative (arguments to segments.fun can be provided via the ... argument, see example for segplot).

Value

For prepanel.segplot a list with components xlim and ylim.

Author(s)

Deepayan Sarkar [email protected]

See Also

segplot

---

Plot a smoothing line with standard error bounds.

Description

Plot a smoothing line with standard error bounds. This is based on the stat_smooth function from ggplot2.

Usage

panel.smoother(x, y, form = y ~ x, method = "loess", ...,
    se = TRUE, level = 0.95, n = 100,
    col = plot.line$col, col.se = col,
    lty = plot.line$lty, lwd = plot.line$lwd,
    alpha = plot.line$alpha, alpha.se = 0.25, border = NA,
    ## ignored: ##
    subscripts, group.number, group.value,
    type, col.line, col.symbol, fill,
    pch, cex, font, fontface, fontfamily)

Arguments

x, y	data points. If these are missing, they will be looked for in the environment of form. So in many cases you can skip these if passing form. In fact, for convenience, the formula can be passed as the first argument (i.e. x).
form, method	the smoothing model is constructed (approximately) as method(form, data = list(x=x, y=y), ...). See the Examples section for common choices.
...	further arguments passed on to the model function (method).
se, level	estimate standard errors on the smoother, at the given level, and plot these as a band.
n	number of equi-spaced points on which to evaluate the smooth function.
col, col.se, lty, lwd, alpha, alpha.se, border	graphical parameters. col and alpha apply to the smoothing line, while col.se and alpha.se apply to the shaded se region.
subscripts, group.number, group.value, type, col.line, col.symbol, fill, pch, cex, font, fontface, fontfamily	ignored.

Details

This should work with any model function that takes a formula argument, and has a predict method with a se argument.

Author(s)

Felix Andrews [email protected]

Based on stat_smooth by Hadley Wickham.

See Also

panel.loess, panel.quantile, stat_smooth

Examples

set.seed(1)
xy <- data.frame(x = runif(100),
                 y = rt(100, df = 5),
                 y2 = rt(100, df = 5) + 1)

xyplot(y ~ x, xy, panel = function(...) {
       panel.xyplot(...)
       panel.smoother(..., span = 0.9)
})

## per-group layers with glayer (pass `...` to get styles)
xyplot(y + y2 ~ x, xy) +
  glayer(panel.smoother(...))

## natural spline with 5 degrees of freedom
if (require("splines"))
  xyplot(y ~ x, xy) +
    layer(panel.smoother(y ~ ns(x,5), method = "lm"))

## thin plate regression spline with smoothness
## chosen by cross validation (see ?mgcv::gam)
if (require("mgcv"))
  xyplot(y ~ x, xy) +
    layer(panel.smoother(y ~ s(x), method = "gam"))

## simple linear regression with standard errors:
xyplot(y ~ x, xy) +
  layer(panel.smoother(x, y, method = "lm"), style = 2)

---