To illustrate this type of graph we will consider some surface elevation data that is available in the geoR package and was used in the blog post on level plots. The data set in this package is called elevation and stores the elevation height in feet (as multiples of ten feet) for a grid region of x and y coordinates (recorded as multiples of 50 feet). This post has details of the various operations that are undertaken to prepare the data for graphing.

Base Graphics

Fast Tube by Casper

The function persp is the base graphics function for creating wireframe surface plots. The persp function requires a list of x and y values covering the grid of vertical values which is specified as the z variable. The heights for the display are specified as a table of values which we saved previously as the object z during the calculations when the local trend surface model was fitted to the data. The text on the axis labels are specified by the xlab and ylab function arguments and the main argument determines the overall title for the graph.

persp(seq(10, 300, 5), seq(10, 300, 5), z, phi = 45, theta = 45,
  xlab = "X Coordinate (feet)", ylab = "Y Coordinate (feet)",
  main = "Surface elevation data"
)

The function arguments phi and theta are used to rotate the viewing angle of the surface. Trial and error is probably the way to go when setting these as good choices depend entirely on the shape of the surface being displayed.

Base Graphics Surface Plot

The surface is clear and easy to determine the shape and variation in height across the x and y grid coordinates.

Lattice Graphics

Fast Tube by Casper

The lattice graphics package has a function wireframe and we use the data in the object elevation.fit to create the graph. We use the formula interface to specify first the z axis data (the heights) followed by the two variables specifying the x and y axis coordinates for the data.

wireframe(Height ~ x*y, data = elevation.fit,
  xlab = "X Coordinate (feet)", ylab = "Y Coordinate (feet)",
  main = "Surface elevation data",
  drape = TRUE,
  colorkey = TRUE,
  screen = list(z = -60, x = -60)
)

The axes labels and title are specified in the same way as the base graphics with the xlab, ylab and main function arguments. A colour key is added using the colorkey function argument and setting it to TRUE.

Lattice Graphics Surface Plot

The surface produced by the wireframe function is similar to the persp function with the main difference between the colours used on the surface.

This blog post is summarised in a pdf leaflet on the Supplementary Material page.

To illustrate this type of graph we will consider some surface elevation data that is available in the geoR package. The data set in this package is called elevation and stores the elevation height in feet (as multiples of ten feet) for a grid region of x and y coordinates (recorded as multiples of 50 feet). To access this data we load the geoR pacakage and then use the data function:

require(geoR)
data(elevation)

For some packages we need the call to the data function to make a set of data available for our use. The elevation object is not a data frame so our first step is to create our own data frame to be used to create the level plots using the different graphics packages.

elevation.df = data.frame(x = 50 * elevation$coords[,"x"],
  y = 50 * elevation$coords[,"y"], z = 10 * elevation$data)

We extract the x and y grid coordinates and the height values, multiplying them by 50 and 10 respectively to convert to feet for the graphs. Rather than trying to plot the individual values we need to create a surface to cover the whole grid region as the points themselves are too sparse. We make use of the loess function to fit a local polynomial trend surface (using weighted least squares) to approximate the elevation across the whole region. The function call for a local quadratic surface is shown below:

elevation.loess = loess(z ~ x*y, data = elevation.df,
  degree = 2, span = 0.25)

The next stage is to extract heights from this fitted surface at regular intervals across the whole grid region of interest – which runs from 10 to 300 feet in both the x and y directions. The expand.grid function creates an array of all combinations of the x and y values that we specify in a list. We choose a range every foot from 10 to 300 feet to create a fine grid:

elevation.fit = expand.grid(list(x = seq(10, 300, 1), y = seq(10, 300, 1)))

The predict function is then used to estimate the surface height at all of these combinations of x and y coordinates covering our grid region. This is saved as an object z which will be used by the base graphics function:

z = predict(elevation.loess, newdata = elevation.fit)

The lattice and ggplot2 expect the data in a different format so we make use of the as.numeric function to convert from a table of heights to a single column and append to the object we create based on all combinations of x and y coordinates:

elevation.fit$Height = as.numeric(z)

The data is now in a format that can be used to create the level plots in the various packages.

Base Graphics

The function image in the base graphics package is the function we use to create a level plot. This function requires a list of x and y values that cover the grid of vertical values that will be used to create the surface. These heights are specified as a table of values, which in our case was saved as the object z during the calculations on the local trend surface.

The text on the axis labels are specified by the xlab and ylab function arguments and the main argument determines the overall title for the graph. The function call below creates the level plot:

image(seq(10, 300, 1), seq(10, 300, 1), z,
  xlab = "X Coordinate (feet)", ylab = "Y Coordinate (feet)",
  main = "Surface elevation data")
box()

After the image function is used we call the box function mainly for aesthetic purposes to ensure there is a line surrounding the level plot. The graph that is created is shown below:

Base Graphics Level Plot

The default colour scheme used by the base graphics produces an attractive level plot graph where we can easily see the variation in height across the grid region. It is basically a fancy version of a contour plot where the regions between the contour lines are coloured with different shades indicating the height in those regions.

Lattice Graphics

The lattice graphics package provides a function levelplot for this type of graphical dispaly. We use the data stored in the object elevation.fit to create the graph with lattice graphics.

levelplot(Height ~ x*y, data = elevation.fit,
  xlab = "X Coordinate (feet)", ylab = "Y Coordinate (feet)",
  main = "Surface elevation data",
  col.regions = terrain.colors(100)
)

The formula is used to specify which variable to use for the three axes and a data frame where the values are stored – as there are three dimensions it is the z axis that is specified on the left hand side of the formula. The axes labels and title are specified in the same way as the base graphics.

The range of colours used in the lattice level plot can be specified as a vector of colours to the col.regions argument of the function. We make use of the terrian.colors function to create this vector which a range of 100 colours which are less striking than those used above with the base graphics. The level plot that we can is shown here:

Lattice Graphics Level Plot

This is in general similar to the base graphics display but the actual plot region is a different shape that makes things look slightly different.

ggplot2

The ggplot2 package also provides facilities for creating a level plot making use of the tile geom to create the desired graph. The function ggplot forms the basis of the graph and various other options are used to customise the graph:

ggplot(elevation.fit, aes(x, y, fill = Height)) + geom_tile() +
  xlab("X Coordinate (feet)") + ylab("Y Coordinate (feet)") +
  opts(title = "Surface elevation data") +
  scale_fill_gradient(limits = c(7000, 10000),low = "black",high = "white") +
  scale_x_continuous(expand = c(0,0)) +
  scale_y_continuous(expand = c(0,0))

This large number of options that are added to the graph change various settings. The choice of colours for the heights used on graph is selected by the scale_fill_gradient function with colours ranging from black to white. The scale_x_continuous and scale_y_continuous options are used to stretch the tiles to cover the whole grid region covering up the default gray background – this makes the graph more visually appealing. The graph that is produced is shown here:

ggplot2 Level Plot

The graph from ggplot2 is visually as impressive as the other graphs – there is more smoothing between the colours which blurs some of the lines on the other graphs because of the type of colour gradient that was selected.

This blog post is summarised in a pdf leaflet on the Supplementary Material page.

There is a set of data relating trunk circumference (in mm) to the age of Orange trees where data was recorded for five trees. This data is available in the data frame Orange and we make a copy of this data set so that we can remove the ordering that is recorded for the Tree identifier variable. We create a new factor after converting the old factor to a numeric string:

orange.df = Orange
orange.df$Tree = factor(as.numeric(orange.df$Tree))

The purpose of this step is to set up the variable for use in the linear model. The simplest model assumes that the relationship between circumference and age is the same for all five trees and we fit this model as follows:

orange.mod1 = lm(circumference ~ age, data = orange.df)

The summary of the fitted model is shown here:

> summary(orange.mod1)
 
Call:
lm(formula = circumference ~ age, data = orange.df)
 
Residuals:
      Min        1Q    Median        3Q       Max 
-46.31030 -14.94610  -0.07649  19.69727  45.11146 
 
Coefficients:
             Estimate Std. Error t value Pr(>|t|)    
(Intercept) 17.399650   8.622660   2.018   0.0518 .  
age          0.106770   0.008277  12.900 1.93e-14 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1 
 
Residual standard error: 23.74 on 33 degrees of freedom
Multiple R-squared: 0.8345,     Adjusted R-squared: 0.8295 
F-statistic: 166.4 on 1 and 33 DF,  p-value: 1.931e-14

The test on the age parameter provides very strong evidence of an increase in circumference with age, as would be expected. The next stage is to consider how this model can be extended – one idea is to have a separate intercept for each of the five trees. This new model assumes that the increase in circumference is consistent between the trees but that the growth starts at different rates. We fit this model and get the summary as follows:

> orange.mod2 = lm(circumference ~ age + Tree, data = orange.df)
> summary(orange.mod2)
 
Call:
lm(formula = circumference ~ age + Tree, data = orange.df)
 
Residuals:
    Min      1Q  Median      3Q     Max 
-30.505  -8.790   3.738   7.650  21.859 
 
Coefficients:
             Estimate Std. Error t value Pr(>|t|)    
(Intercept) -4.457493   7.572732  -0.589   0.5607    
age          0.106770   0.005321  20.066  < 2e-16 ***
Tree2        5.571429   8.157252   0.683   0.5000    
Tree3       17.142857   8.157252   2.102   0.0444 *  
Tree4       41.285714   8.157252   5.061 2.14e-05 ***
Tree5       45.285714   8.157252   5.552 5.48e-06 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1 
 
Residual standard error: 15.26 on 29 degrees of freedom
Multiple R-squared: 0.9399,     Adjusted R-squared: 0.9295 
F-statistic:  90.7 on 5 and 29 DF,  p-value: < 2.2e-16

The additional term is appended to the simple model using the + in the formula part of the call to lm. The first tree is used as the baseline to compare the other four trees against and the model summary shows that tree 2 is similar to tree 1 (no real need for a different offset) but that there is evidence that the offset for the other three trees is significantly larger than tree 1 (and tree 2). We can compare the two models using an F-test for nested models using the anova function:

> anova(orange.mod1, orange.mod2)
Analysis of Variance Table
 
Model 1: circumference ~ age
Model 2: circumference ~ age + Tree
  Res.Df     RSS Df Sum of Sq      F    Pr(>F)    
1     33 18594.7                                  
2     29  6753.9  4     11841 12.711 4.289e-06 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Here there are four degrees of freedom used up by the more complicated model (four parameters for the different trees) and the test comparing the two models is highly significant. There is very strong evidence of a difference in starting circumference (for the data that was collected) between the trees.

We can extended this model further by allowing the rate of increase in circumference to vary between the five trees. This additional term can be included in the linear model as an interaction term, assuming that tree 1 is the baseline. An interaction term is included in the model formula with a : between the name of two variables. For the Orange tree data the new model is fitted thus:

> orange.mod3 = lm(circumference ~ age + Tree + age:Tree, data = orange.df)
> summary(orange.mod3)
 
Call:
lm(formula = circumference ~ age + Tree + age:Tree, data = orange.df)
 
Residuals:
    Min      1Q  Median      3Q     Max 
-18.061  -6.639  -1.482   8.069  16.649 
 
Coefficients:
              Estimate Std. Error t value Pr(>|t|)    
(Intercept)  1.920e+01  8.458e+00   2.270  0.03206 *  
age          8.111e-02  8.119e-03   9.991 3.27e-10 ***
Tree2        5.234e+00  1.196e+01   0.438  0.66544    
Tree3       -1.045e+01  1.196e+01  -0.873  0.39086    
Tree4        7.574e-01  1.196e+01   0.063  0.95002    
Tree5       -4.566e+00  1.196e+01  -0.382  0.70590    
age:Tree2    3.656e-04  1.148e-02   0.032  0.97485    
age:Tree3    2.992e-02  1.148e-02   2.606  0.01523 *  
age:Tree4    4.395e-02  1.148e-02   3.828  0.00077 ***
age:Tree5    5.406e-02  1.148e-02   4.708 7.93e-05 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1 
 
Residual standard error: 10.41 on 25 degrees of freedom
Multiple R-squared: 0.9759,     Adjusted R-squared: 0.9672 
F-statistic: 112.4 on 9 and 25 DF,  p-value: < 2.2e-16

Interesting we see that there is strong evidence of a difference in the rate of change in circumference for the five trees. The previously observed difference in intercepts is now longer as strong but this parameter is kept in the model – there are plenty of books/websites that discuss this marginality restrictin on statistical models. The fitted model described above can be created using lattice graphics with a custom panel function making use of available panel functions for fitting and drawing a linear regression line for each panel of a Trellis display. The function call is shown below:

xyplot(circumference ~ age | Tree, data = orange.df,
  panel = function(x, y, ...)
  {
    panel.xyplot(x, y, ...)
    panel.lmline(x, y, ...)
  }
)

The panel.xyplot and panel.lmline functions are part of the lattice package along with many other panel functions and can be built up to create a display that differs from the standard. The graph that is produced:

Analysis of Covariance Model fitted to the Orange Tree data

This graph clearly shows the different relationships between circumference and age for the five trees. The residuals from the model can be plotted against fitted values, divided by tree, to investigate the model assumptions:

xyplot(resid(orange.mod3) ~ fitted(orange.mod3) | orange.df$Tree,
  xlab = "Fitted Values",
  ylab = "Residuals",
  main = "Residual Diagnostic Plot",
  panel = function(x, y, ...)
  {
    panel.grid(h = -1, v = -1)
    panel.abline(h = 0)
    panel.xyplot(x, y, ...)
  }
)

The residual diagnostic plot is:

Residual diagnostic plot for the analysis of covariance model fitted to the Orange Tree data

There are no obvious problematic patterns in this graph so we conclude that this model is a reasonable representation of the relationship between circumference and age.

Additional: The analysis of variance table comparing the second and third models shows an improvement by moving to the more complicated model with different slopes:

> anova(orange.mod2, orange.mod3)
Analysis of Variance Table
 
Model 1: circumference ~ age + Tree
Model 2: circumference ~ age + Tree + age:Tree
  Res.Df    RSS Df Sum of Sq      F    Pr(>F)    
1     29 6753.9                                  
2     25 2711.0  4    4042.9 9.3206 9.402e-05 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

The box and whisker plot is an effective way to investigate the distribution of a set of data. For example, skewness can be identified from the box and whisker as the display does not make any assumptions about the underlying distribution of the data. The extreme values at either end of the scale are sometimes included on the display to show how far they extend beyond the majority of the data.

To illustrate creating box and whisker plots we consider UK meteorological data that has been collected on a monthly basis at Southampton, UK between 1950 and 1999 and is publicly available. This data is available from the UK Met Office and we will compare the range of temperatures recorded in each month of the year over this period by creating box and whisker plots with the different packages.

The data is assumed to have been imported into R and stored in a data frame called soton.df. An extract of the data is shown here:

    Year Month Max.Temp Min.Temp Frost  Rain
1   1950   Jan      7.7      2.8     7  20.1
2   1950   Feb     10.3        4     4 127.0
3   1950   Mar     13.0      4.5     2  39.4
4   1950   Apr     13.6      4.7     0  62.0
5   1950   May     17.9      7.8     0  32.2

Base Graphics

Fast Tube by Casper

The base graphics approach makes use of the boxplot function to create box and whisker plots. In this situation the function can be used with a formula rather than specifying two separate vectors of data – we can specify a data frame to point towards a source of data to be used in the graph. For the temperature data we use this code:

boxplot(Max.Temp ~ Month, data = soton.df,
  xlab = "Month", ylab = "Maximum Temperature",
  main = "Temperature at Southampton Weather Station (1950-1999)"
)

The horizontal and vertical axes labels are specified using the xlab and ylab arguments respectively and the title of the plot is created using the main argument. The box and whisker plot is shown here:

Base Graphics Box and Whisker Plot

The function boxplot makes it easy to create a reasonably attractive box and whisker plot. The variation in the distribution of temperatures across the year can be seen from the graph.

Lattice Graphics

Fast Tube by Casper

In the lattice graphics package there is a function bwplot which is used to create box and whisker plots. The function call also uses a formula to specify the x and y variables to use on the graph. The function call arguments are identical to the boxplot function in base graphics:

bwplot(Max.Temp ~ Month, data = soton.df,
  xlab = "Month", ylab = "Maximum Temperature",
  main = "Temperature at Southampton Weather Station (1950-1999)"
)

The variable Month is categorical so a separate box and whisker summary is created for each month separately. The lattice version of the graph is shown here:

Lattice Graphics Box and Whisker Plot

This is very similar to the box and whisker plot created by base graphics with a similar level of effort required. The main difference is the use of a circle rather than a line to identify the location of the median of the data.

ggplot2

Fast Tube by Casper

In the ggplot2 package there is a general function ggplot that is used to create graphs of any type. We make use of the boxplot geom to create a box and whisker plot following the standard approach. The first step is to specify a data frame to use to create the graph and then map the columns of this data frame, via the \texttt{aes} argument, to the different axes or other aesthetics (such as colour or symbol shape). The particular geom is used to specify the type of plot that we want to create. Our final step is to add on the various axes labels and an overall title to the graph.

ggplot(soton.df, aes(Month, Max.Temp)) + geom_boxplot() +
  ylab("Maximum Temperature") +
  opts(title = "Temperature at Southampton Weather Station (1950-1999)")

The ggplot2 version of box and whisker plots is shown here:

ggplot2 Graphics Box and Whisker Plot

The distinctive gray background used by ggplot2 is an obvious visual difference compared to the default clear background used in the other two approaches. The boxes themselves have a cleaner look in this graph than the other two methods and the overall look is slick.

This blog post is summarised in a pdf leaflet on the Supplementary Material page.

In this post we will consider the case of simple linear regression with one response variable and a single independent variable. For this example we will use some data from the book Mathematical Statistics with Applications by Mendenhall, Wackerly and Scheaffer (Fourth Edition – Duxbury 1990). This data is for a study in central Florida where 15 alligators were captured and two measurements were made on each of the alligators. The weight (in pounds) was recorded with the snout vent length (in inches – this is the distance between the back of the head to the end of the nose).

The purpose of using this data is to determine whether there is a relationship, described by a simple linear regression model, between the weight and snout vent length. The authors analysed the data on the log scale (natural logarithms) and we will follow their approach for consistency. We first create a data frame for this study:

alligator = data.frame(
  lnLength = c(3.87, 3.61, 4.33, 3.43, 3.81, 3.83, 3.46, 3.76,
    3.50, 3.58, 4.19, 3.78, 3.71, 3.73, 3.78),
  lnWeight = c(4.87, 3.93, 6.46, 3.33, 4.38, 4.70, 3.50, 4.50,
    3.58, 3.64, 5.90, 4.43, 4.38, 4.42, 4.25)
)

As with most analysis the first step is to perform some exploratory data analysis to get a visual impression of whether there is a relationship between weight and snout vent length and what form it is likely to take. We create a scatter plot of the data as follows:

xyplot(lnWeight ~ lnLength, data = alligator,
  xlab = "Snout vent length (inches) on log scale",
  ylab = "Weight (pounds) on log scale",
  main = "Alligators in Central Florida"
)

The scatter plot is shown here:

Scatter plot of the weight and snout vent length for alligators caught in central Florida

The graph suggests that weight (on the log scale) increases linearly with snout vent length (again on the log scale) so we will fit a simple linear regression model to the data and save the fitted model to an object for further analysis:

alli.mod1 = lm(lnWeight ~ lnLength, data = alligator)

The function lm fits a linear model to data are we specify the model using a formula where the response variable is on the left hand side separated by a ~ from the explanatory variables. The formula provides a flexible way to specify various different functional forms for the relationship. The data argument is used to tell R where to look for the variables used in the formula.

Now that the model is saved as an object we can use some of the general purpose functions for extracting information from this object about the linear model, e.g. the parameters or residuals. The big plus with R is that there are functions defined for different types of model, using the same name such as summary, and the system works out what function we intended to use based on the type of object saved. To create a summary of the fitted model:

> summary(alli.mod1)
 
Call:
lm(formula = lnWeight ~ lnLength, data = alligator)
 
Residuals:
     Min       1Q   Median       3Q      Max 
-0.24348 -0.03186  0.03740  0.07727  0.12669 
 
Coefficients:
            Estimate Std. Error t value Pr(>|t|)    
(Intercept)  -8.4761     0.5007  -16.93 3.08e-10 ***
lnLength      3.4311     0.1330   25.80 1.49e-12 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1 
 
Residual standard error: 0.1229 on 13 degrees of freedom
Multiple R-squared: 0.9808,     Adjusted R-squared: 0.9794 
F-statistic: 665.8 on 1 and 13 DF,  p-value: 1.495e-12

We get a lot of useful information here without being too overwhelmed by pages of output.

The estimates for the model intercept is -8.4761 and the coefficient measuring the slope of the relationship with snout vent length is 3.4311 and information about standard errors of these estimates is also provided in the Coefficients table. We see that the test of significance of the model coefficients is also summarised in that table so we can see that there is strong evidence that the coefficient is significantly different to zero – as the snout vent length increases so does the weight.

Rather than stopping here we perform some investigations using residual diagnostics to determine whether the various assumptions that underpin linear regression are reasonable for our data or if there is evidence to suggest that additional variables are required in the model or some other alterations to identify a better description of the variables that determine how weight changes.

A plot of the residuals against fitted values is used to determine whether there are any systematic patterns, such as over estimation for most of the large values or increasing spread as the model fitted values increase. To create this plot we could use the following code:

xyplot(resid(alli.mod1) ~ fitted(alli.mod1),
  xlab = "Fitted Values",
  ylab = "Residuals",
  main = "Residual Diagnostic Plot",
  panel = function(x, y, ...)
  {
    panel.grid(h = -1, v = -1)
    panel.abline(h = 0)
    panel.xyplot(x, y, ...)
  }
)

We create our own custom panel function using the buliding blocks provided by the lattice package. We start by creating a set of grid lines as the base layer and the h=-1 and v=-1 tell lattice to align these with the labels on the axes. We then create a solid horizontal line to help distinguish between positive and negative residuals. Finally we get the points plotted on the top layer.

The residual diagnostic plot is shown below:

Residual Diagnostics Plot for the Linear Regression Model

The plot is probably ok but there are more cases of positive residuals and when we consider a normal probability plot we see that there are some deficiencies with the model:

qqmath( ~ resid(alli.mod1),
  xlab = "Theoretical Quantiles",
  ylab = "Residuals"
)

The function resid extracts the model residuals from the fitted model object. The plot is shown here:

Quantile-Quantile Plot for the Linear Regression Model

We would hope that this plot showed something approaching a straight line to support the model assumption about the distribution of the residuals. This and the other plots suggest that further tweaking to the model is required to improve the model or a decision would need to be made about whether to report the model as is with some caveats about its usage. I am interested in the thoughts/comments/suggestions from how other people would proceed when faced with this situation – feel free to add in the comments.

Related posts:

• Manual variable selection with the dropterm function.
• The update function for simplifying model selection.
• Including factors in a regression model via analysis of covariance.

To illustrate creating a scatter plot we will use a simple data set for the population of the UK between 1992 and 2009. This data is saved in a data frame uk.df using the following command:

uk.df = data.frame(Year = 1992:2009,
  Population = c(57770, 57933, 58096, 58258, 58418, 58577,
  58743, 58925, 59131, 59363, 59618, 59894, 60186, 60489,
  60804, 61129, 61461, 61796)
)

For this example the data is recorded in thousands to make the graph easier to read and there is no benefit or noticeable improvement to be seen by using greater detail.

Base Graphics

Fast Tube by Casper

In the base graphics system the general purpose plot function can be used to create a scatter plot for the UK population data set that we created. The first two arguments to the plot function are the x and y variables respectively. The following code will create a scatter plot, including various labels:

plot(uk.df$Year, uk.df$Population,
  xlab = "Year", ylab = "Total Population (Thousands)",
  main = "UK Population (1992-2009)", pch = 16)

The labels for the x and y axes are specified via the xlab and ylab arguments to the plot function and the main argument specifies the title for the plot.

Base Graphics Histogram

The graph itself is plain and functional which solid circles indicating the population (in thousands) for each of the years covered by the data.

Lattice Graphics

Fast Tube by Casper

The lattice graphics package provides a function xyplot specifically to create scatter plots and the function is used in a similar way to the base graphics approach. The first argument to the function is a formula describing the relationship to be plotted on the graph, with the y variable preceding the x variable as we are used to when describing mathematical fomula such as y=a+bx. The data frame is specified with the data argument to simplify the expression in the formula. The code used is as follows:

xyplot(Population ~ Year, data = uk.df,
  xlab = "Year", ylab = "Total Population (Thousands)",
  main = "UK Population (1992-2009)",
  scales = list(x = list(at = seq(1992, 2009, 2)))
)

The axis labels and the overall title for the graph are specified in the same way as the base graphics system. We indulge in some fine tuning of the labels on the x axis via the scales argument – here we indicate that every second year should be included on the label starting in 1992 and running until 2009. The lattice graph is shown here for comparison with the graphs created using the other two packages:

Lattice Graphics Scatter Plot

There are very few visual differences between the lattice and base graphics. In lattice graphics an object is created that can be edited to add or remove components and then printed to the screen. This approach is more flexible than the base graphics where the components are painted on top of each other and the use of themes in lattice will make it easier to keep a consistent look to all graphs in a document.

ggplot2

Fast Tube by Casper

In the ggplot2 package the ggplot function is used to create graphs of all types rather than having a separate function defined for each type of graph. The first argument is adata frame with the data to be plotted and the aes argument specifies the aesthetics associated with the graph such as the point symbol, size or colour. In this case the Year variable appears on the x axis and the Population variable on the y axis. The code to create the scatter plot is shown here:

ggplot(uk.df, aes(Year, Population)) + geom_point() +
  xlab("Year") + ylab("Total Population (Thousands)") +
  opts(title = "UK Population (1992-2009)")

The geom_point specifies the type of graph to create (a scatter plot in this situation and this highlights the flexibility of the ggplot2 package as changing the geom will create a new type of graph) and the labels for the graph are created by adding them to the graph with the xlab, ylab and opts functions. The graph is shown below:

ggplot2 Scatter plot

This graph is not greatly different to the scatter plot created using the base and lattice packages. The default theme in the ggplot2 package has a gray background with white grid lines that allows easy visual recognition of graphs created using this package.

This blog post is summarised in a pdf leaflet on the Supplementary Material page.

The main functions of interest are the pair trellis.par.get and trellis.par.set that are used to get hold of the settings for the current graphics device or to set a list of new parameters. The parameters themselves are described by a list object with information about a large range of possible options. To extract and save this information we would do the following:

my.theme = trellis.par.get()

To get a feel for how many options can be specified we can look at the names of the components that make up this list:

> names(my.theme)
 [1] "grid.pars"         "fontsize"          "background"       
 [4] "clip"              "add.line"          "add.text"         
 [7] "plot.polygon"      "box.dot"           "box.rectangle"    
[10] "box.umbrella"      "dot.line"          "dot.symbol"       
[13] "plot.line"         "plot.symbol"       "reference.line"   
[16] "strip.background"  "strip.shingle"     "strip.border"     
[19] "superpose.line"    "superpose.symbol"  "superpose.polygon"
[22] "regions"           "shade.colors"      "axis.line"        
[25] "axis.text"         "axis.components"   "layout.heights"   
[28] "layout.widths"     "box.3d"            "par.xlab.text"    
[31] "par.ylab.text"     "par.zlab.text"     "par.main.text"    
[34] "par.sub.text"

There are a total of 34 components of this list that each have a set of other parameters that can be set by the user. For example, if we wanted to find out how lattice will draw a scatter plot then the plot.symbol component of the list is where we should be looking. We extract this information as follows:

> my.theme$plot.symbol
$alpha
[1] 1
 
$cex
[1] 0.8
 
$col
[1] "#0080ff"
 
$font
[1] 1
 
$pch
[1] 1
 
$fill
[1] "transparent"

The plot symbol is 80% of the overall size specified for the system and the empty circle is the first shape symbol available – set by the pch component.

When there are groups in the data being plotted different shape symbols, colours etc. can be specified as part of the superpose.symbol component of the theme list. By default the settings are:

> my.theme$superpose.symbol
$alpha
[1] 1 1 1 1 1 1 1
 
$cex
[1] 0.8 0.8 0.8 0.8 0.8 0.8 0.8
 
$col
[1] "#0080ff"   "#ff00ff"   "darkgreen" "#ff0000"   "orange"    "#00ff00"
"brown"    
 
$fill
[1] "#CCFFFF" "#FFCCFF" "#CCFFCC" "#FFE5CC" "#CCE6FF" "#FFFFCC" "#FFCCCC"
 
$font
[1] 1 1 1 1 1 1 1
 
$pch
[1] 1 1 1 1 1 1 1

There are seven possible groups that are specified in the default theme and the various options are in many cases the same name as for the base graphics system. If we wanted to make the symbols large then the cex option specifies a multiplier relative to the base size for symbols. The pch is used to indicate which plot symbol to use, and these are again the same as those provided when using base graphics.

So if we wanted to change the symbols to solid circles then we would adjust the my.theme list object to indicate a different plot symbol shape:

> my.theme$superpose.symbol$pch = rep(16, 7)
> my.theme$superpose.symbol
$alpha
[1] 1 1 1 1 1 1 1
 
$cex
[1] 0.8 0.8 0.8 0.8 0.8 0.8 0.8
 
$col
[1] "#0080ff"   "#ff00ff"   "darkgreen" "#ff0000"   "orange"    "#00ff00"
"brown"    
 
$fill
[1] "#CCFFFF" "#FFCCFF" "#CCFFCC" "#FFE5CC" "#CCE6FF" "#FFFFCC" "#FFCCCC"
 
$font
[1] 1 1 1 1 1 1 1
 
$pch
[1] 16 16 16 16 16 16 16

To update the graphics settings we would need to use the trellis.par.set function:

> trellis.par.set(my.theme)

The new settings can be accessed via:

> show.settings()

They are now as shown here:

Lattice Graphics Settings

The plot symbols are now solid rather than empty circles.

The shape of the histogram is determined by the width and number of regions that divided up the data. A histogram provides an indication the following features of a set of data: the general shape, symmetry or skewness of data and modality (uni-, bi- or multi-modal). There are some situations where a different type of graph would be preferable but histograms are useful for describing the general features of the distribution of a set of data.

To illustrate creating a histogram we consider data from the AFL sports league in Australia and the total number of points scored by the home team in each fixture. If we assume that the data is in a comma separated text file, called afl_2003_2007.csv, then we would import that data using the following command saving the results in a data frame:

afl.df = read.csv("afl_2003_2007.csv")

Edit: The data is available as AFL Data Set. Change the file extension manually to csv or change the command to reflect the different file name.

Base Graphics

Fast Tube by Casper

In base graphics the function hist is used to create a histogram with the first argument being the name of the vector that contains the data to be plotted. The x-axis is given a label using the xlab argument and the main argument is used to add a title to the graph. Code to create a histogram of home points is shown below:

hist(afl.df$Home.Total, xlab = "Home Points",
  main = "Histogram of Points Scored at Home\nAFL 2003-2007")

The default option is to display bars representing the frequency of data values in each of the ranges and the overall look of the graph is basic as shown here:

Base Graphics Histogram

The default algorithm for selecting number of bins to use for the histogram usually makes a sensible selection but this can be specified if required.

Lattice Graphics

Fast Tube by Casper

In the lattice graphics package there is a function histogram and we make use of the formula to specify a single variable for the number of points scored by the home team. The specification for the axis labels and graph title are the same as for the base graphics package. The equivalent graph is created using the following code:

histogram( ~ Home.Total, data = afl.df, xlab = "Home Points",
  main = "Histogram of Points Scored at Home\nAFL 2003-2007")

Here the default option is the work with proportions of the total number of data points rather than counts so the shape of the distribution is slightly different when compared to the base graphics plot. The lattice version is shown below:

Lattice Graphics Histogram

The main other difference is the choice of colour for the bars in the histogram and these can be adjusted by changing the global theme for lattice.

ggplot2

Fast Tube by Casper

The ggplot2 library uses a general purpose graphics function called ggplot to create graphs of all types and the geom specifies the type of display to create, in this case a histogram. Components that make up the graph are added sequentially to build up the whole plot and in the example below we add axis labels and a main title.

ggplot(afl.df, aes(Home.Total)) + geom_histogram() +
  xlab("Home Points") + ylab("Frequency") +
  opts(title = "Histogram of Points Scored at Home\nAFL 2003-2007")

The default theme for ggplot2 is distinctive and the histogram is shown in the graph below:

ggplot 2 Histogram

The default number of bins is larger compared to base and lattice graphics which provides a rough distribution in this particular case. The online ggplot2 manual is a good source of information about customising graphs created using this approach.

This blog post is summarised in a pdf leaflet on the Supplementary Material page.

In this post we will considered creating a dot plot using the base graphics, lattice graphics and ggplot2 approaches. To illustrate creating a dot plot we used data from the FAO website on the total irrigation area for Africa, Latin America, North America and Europe. We create a data frame using the following code:

irrigation.df = data.frame(
  Region = rep(c("Africa", "Latin America", "North America", "Europe"), 4),
  Year = factor(c(rep(1980, 4), rep(1990, 4), rep(2000, 4), rep(2007, 4))),
  Area = c(9.3, 12.7, 21.2, 18.8, 11.0, 15.5, 21.6, 25.3,
    13.2, 17.3, 23.3, 26.7, 13.6, 17.3, 23.8, 26.3)
)

Base Graphics

Fast Tube by Casper

In the base graphics system we build up the dotplot with a series of commands. The first function call creates the graph region based on the data set but we do not plot any data by setting the type = “n” argument. The axis labels for the horizontal and vertical scales are set along with the title in the initial function call:

plot(irrigation.df$Area, irrigation.df$Region, xlab = "Area",
  ylab = "Region", main = "Irrigation Area by Region", type = "n")

To add the points with separate colours for each of the four years we use the points function and subset to the particular year by testing a condition on the year. The col argument is used with a text string to specify the colour for the symbols for the given year:

points(irrigation.df$Area[irrigation.df$Year == 1980],
  irrigation.df$Region[irrigation.df$Year == 1980], col = "black", pch = 16)
points(irrigation.df$Area[irrigation.df$Year == 1990],
  irrigation.df$Region[irrigation.df$Year == 1990], col = "blue", pch = 16)
points(irrigation.df$Area[irrigation.df$Year == 2000],
  irrigation.df$Region[irrigation.df$Year == 2000], col = "red", pch = 16)
points(irrigation.df$Area[irrigation.df$Year == 2007],
  irrigation.df$Region[irrigation.df$Year == 2007], col = "green", pch = 16)

The code is rather long winded compared to the using the other two graphics packages. We can add a legend to the graph so that the years can be identified:

legend(10, 4, legend = c("1980", "1990", "2000", "2007"),
  col = c("black", "blue", "red", "green"), pch = 16)

The placement of the legend uses the x and y coordinates within the graph to position the box. All the code above produces the following graph:

Base Graphics Dot Plot

The graph is basic but we can consider the changes over time for the four regions. One downside is that the regions have been labelled with numbers rather than text strings.

Lattice Graphics

Fast Tube by Casper

The lattice graphics package has a function dotplot that is used to create dot plots. The first argument to the function is a formula describing the variables to use for the horizontal and vertical axes. We also specify the data frame to use for the graph and which column to determine different symbols and/or colours to highlight groupings within the plot:

dotplot(Region ~ Area, data = irrigation.df, groups = Year,
  main = "Irrigation Area by Region")

The lattice variant of the graph is shown here:

Lattice Graphics Dot Plot

The graph is simple and very similar to the one produced using the base graphics with the advantage that the R code is not as complicated.

ggplot2

Fast Tube by Casper

The ggplot function is used to create the dot plot where we first specify the name of the data frame with the information to be displayed and then use the aes argument to list the variables to plot on the horizontal and vertical axes. The colour argument determines the variable to use for assigning colours to (usually) a categorical variable.

ggplot(irrigation.df, aes(x = Area, y = Region, colour = Year)) +
  geom_point() + opts(title = "Irrigation Area by Region")

The ggplot2 version of the dot plot is shown below:

ggplot2 Dot Plot

This graph is very similar to the ones produced using the other graphics packages but has the distinctive background and legend style that is used as the default option in ggplot2.

This blog post is summarised in a pdf leaflet on the Supplementary Material page.

In R there are multiple ways for creating graphs, including the base graphics, lattice graphics and the ggplot2 grammar of graphics approach. To illustrate how we can create a bar chart using these packages we will make use of some data taken from the FAO statistics website for the UK in 2007. The data is for production (in metric tonnes) of the top five, in terms of production, food and agricultural commodities.

The first step before creating the graphs is to prepare the data in a format that can be used by the graphing functions. As this dataset is small we can manually create the data object. To make the labels on the graph less cluttered the production is recorded as 1,000s of metric tonnes.

The R code to create the data object is shown here:

uk2007 = data.frame(Commodity =
  factor(c("Cow milk", "Wheat", "Sugar beet", "Potatoes", "Barley"),
    levels = c("Cow milk", "Wheat", "Sugar beet", "Potatoes", "Barley")),
  Production = c(14023, 13221, 6500, 5635, 5079))

The levels argument is explicity defined to make sure that the ordering is as required from largest to smallest production rather than being alphabetical which would be how the categories are ordered otherwise.

Base Graphics

Fast Tube by Casper

The base graphics in R provide a function barplot that we can use to create a bar chart. The first argument to the function is the name of the object with the data. The names argument is used to provide the labels for the categories in the graph. We also specify the text for the labels for the x-axis, y-axis and title of the graph with the xlab, ylab and main arguments respectively.

The function call is:

barplot(uk2007\$Production, names = uk2007\$Commodity,
  xlab = "Commodity", ylab = "Production (1,000 MT)",
  main = "UK 2007 Top 5 Food and Agricultural Commodities")

to produce the following graph:

Base Graphics Bar Chart

This graph is visually appealing with sensible space between the bars for the five commodity categories.

Lattice Graphics

Fast Tube by Casper

In the lattice graphics package the barchart function is used to create bar charts. The x and y variables are specified using a formula, which is the standard way when using Trellis graphics. The variable on the vertical axis is specified on the left hand side of the formula and the variable for the horizontal axis is on the right hand side, where they are separated by the tilda character.

barchart(Production $\sim$ Commodity, data = uk2007, xlab = "Commodity",
  ylab = "Production (1,000 MT)",
  main = "UK 2007 Top 5 Food and Agricultural Commodities")

This code produces the following graph:

Lattice Graphics Bar Chart

The main visual difference compared to the base graphics example is the default colours for the bars which is much brighter than the base graphics example. There is also a large gap between the bars in the display.

ggplot2

Fast Tube by Casper

The create the bar chart in the ggplot2 package we use the ggplot function to specify the data to appear in the graph then gradually add in the other components of the graph.

We specify the data frame where the data is stored and then use the aes argument to identify the x and y variables. The geom\_bar function is used to create a bar chart display with the specified data and the last three options in the example are for creating the various labels to be added to the graph.

The graph itself is constructed piece by piece to add the various layers and components on top of the base layer:

ggplot(uk2007, aes(Commodity, Production)) + geom_bar() + xlab("Commodity") +
  ylab("Production (1,000 MT)") +
  opts(title = "UK 2007 Top 5 Food and Agricultural Commodities")

This code produces the following graph:

ggplot2 Bar Chart

The layout of this graph differs mainly with the grid background layout, which by default is a gray with white lines.

This blog post is summarised in a pdf leaflet on the Supplementary Material page.