1.2.1.1 Bar Charts

• Calculating a table of the number of births by day of week and then printing a bar chart to show the number of births by day of week:

# Figure 7
births.dow <- table(births2006.smpl$DOB_WK)
barchart(births.dow)

Notice that many more babies are born on weekdays than on weekends. That’s a little surprising.

You might wonder if there is a difference in the number of births because of the delivery method; maybe doctors just schedule a lot of cesarean sections on weekdays, and natural births occur all the time. This is the type of question that the lattice package is great for answering.

• Eliminate records where the delivery method was unknown and then tabulate the number of births by day of week and method:

# Figure 8
births2006.dm <- transform(births2006.smpl[births2006.smpl$DMETH_REC != "Unknown", ], 
                           DMETH_REC = as.factor(as.character(DMETH_REC)))
dob.dm.tbl <- table(WK = births2006.dm$DOB_WK, MM = births2006.dm$DMETH_REC)
barchart(dob.dm.tbl)

By default, barchart prints stacked bars with no legend and the different colors show different groups. But notice that the different shades aren’t labeled, so it’s not immediately obvious what each shade represents. Let’s try to change the way the chart is displayed.

• Unstack the bars (stack = FALSE) and add a legend (auto.key = TRUE):

# Figure 9
barchart(dob.dm.tbl, stack = FALSE, auto.key = TRUE)

It’s a little easier to see that both types of births decrease on weekends, but it’s still a little difficult to compare values within each group. So let’s try a different approach.

• Split bars into two different panels by telling barchart not to group by color (groups = FALSE) and change to columns (horizontal=FALSE)

# Figure 10
barchart(dob.dm.tbl, groups = FALSE, horizontal = FALSE)

The two different charts are in different panels. Now, we can more clearly see what’s going on. The number of vaginal births decreases on weekends, by maybe 25 to 30%. However, C-sections drop by 50 to 60%. As you can see, lattice graphics let you quickly try different ways to present information, helping you zero in on the method that best illustrates what is happening in the data.

1.2.1.2 Dot plots

Like bar charts, dot plots are useful for showing data where there is a single point for each category, especially when we’re going to summarize larger data tables. For example, let’s look at a chart of data on births by day of week. Is the pattern we saw above a seasonal pattern?

• Create a new table counting births by month, week, and delivery method and then plot the results using a dot plot:

# Figure 11
dob.dm.tbl.alt <- table(WEEK = births2006.dm$DOB_WK, 
                        MONTH = births2006.dm$DOB_MM, 
                        METHOD = births2006.dm$DMETH_REC)
dotplot(dob.dm.tbl.alt, 
        stack    = FALSE, 
        auto.key = TRUE, 
        groups   = TRUE
        )

In this plot, we keep on grouping, so that different delivery methods are shown in different colors (groups = TRUE). To help highlight differences, we’ll disable stacking values (stack = FALSE). Finally, we’ll print a key so that it’s obvious what each symbol represents (auto.key = TRUE).

As you can see, there are slight seasonal differences, but the overall pattern remains the same.

As another example of dot plots, let’s look at the tire failure data in the nutshell package. In 2003, the National Highway Traffic Safety Administration (NHTSA) began a study into the durability of radial tires on light trucks. (See this for links to this study.) Tests were carried out on six different types of tires. Here is a table of the characteristics of the tires:

We focus on only three variables. Time_To_Failure is the time before each tire failed (in hours), Speed_At_Failure_km_h is the testing speed at which the tire failed, and Tire_Type is the type of tire tested. We know that tests were only run at certain stepped speeds; despite the fact that speed is a numeric variable, we can treat it as a factor.

• Show the one continuous variable (time to failure) by the speed at failure for each different type of tire

# Figure 12
library(nutshell)
data(tires.sus)
dotplot(as.factor(Speed_At_Failure_km_h)~Time_To_Failure|Tire_Type, data = tires.sus)

This diagram let’s us clearly see how quickly tires failed in each of the tests. For example, all type D tires failed quickly at the testing speed of 180 km/h, but some type H tires lasted a long time before failure.

1.2.1.3 Histograms

The histogram is a very popular chart for showing the distribution of a variable. As an example of histograms, let’s look at average birth weights, grouped by number of births.

• Show the distribution of average birth weights, split by the number of births:

# Figure 13
histogram(~DBWT|DPLURAL, data = births2006.smpl)

This format helps make each chart readable by itself, but makes it difficult to compare the different groups.

• Stack the charts on top of each other using the layout variable:

# Figure 14
histogram(~DBWT|DPLURAL, data = births2006.smpl, layout = c(1, 5))

It’s easy to see that birth weights are roughly normally distributed within each group, but the mean weight drops as the number of births increases.

1.2.1.4 Density plots

If you’d like to see a single line showing the distribution, instead of a set of columns representing bins, you can use kernel density plots.

• Redraw the example above and replace the histogram with a density plot:

# Figure 15
densityplot(~DBWT|DPLURAL, 
            data   = births2006.smpl, 
            layout = c(1, 5), 
            plot.points = FALSE
            )

By default, densityplot will draw a strip chart under each chart, showing every data point. However, the data set is so big, we specify plot.points = FALSE.

One advantage of density plots over histograms is that you can stack them on top of each other and still read the results.

• Change the conditioning variable (DPLURAL) to a grouping variable so that we can stack these charts on top of each other:

# Figure 16
densityplot(~DBWT, 
            groups   = DPLURAL, 
            data     = births2006.smpl, 
            plot.points = FALSE, 
            auto.key = TRUE
            )

As you can see, it’s easier to compare distribution shapes (and centers) by superimposing the charts.

1.2.1.5 Strip plots

A good alternative to histograms are strip plots, especially when there isn’t much data to plot. Strip plots look similar to dot plots, but they show different information. Dot plots are designed to show one value per category (often a mean or a sum), while strip plots show many values. You can think of strip plots as one-dimensional scatter plots.

As an example of a strip plot, let’s look at the weights of babies born in sets of 4 or more. There were only 44 observations in our data set that match this description.

• Use the subset argument to specify two sets of observations, and add some random vertical noise to make the points easier to read (jitter.data = TRUE):

# Figure 17
stripplot(~DBWT, 
          data   = births2006.smpl, 
          subset = (DPLURAL == "5 Quintuplet or higher"  | DPLURAL == "4 Quadruplet"), 
          jitter.data = TRUE
          )

1.2.1.6 Univariate quantile-quantile plots

A quantile-quantile plot is a useful plot that can compare the distribution of actual data values to a theoretical distribution. It plots quantiles of the observed data against quantiles of a theoretical distribution. If the plotted points form a straight diagonal line (from top right to bottom left), then it is likely that the observed data comes from the theoretical distribution. Quantile-quantile plots are a very powerful technique for seeing how closely a data set matches a theoretical distribution (or how much it deviates from it).

• Plot 100,000 random values from a normal distribution to show what qqmath does:

# Figure 18
qqmath(rnorm(100000))

By default, the function qqmath compares the sample data to a normal distribution. If the sample data is really normally distributed, you’ll see a vertical line.

• Plot a set of quantile-quantile plots for a random sample of 50,000 points from the birth weight data:

# Figure 19
qqmath(~DBWT|DPLURAL, 
       data   = births2006.smpl[sample(1:nrow(births2006.smpl), 50000), ], 
       pch    = 19, 
       cex    = 0.25, 
       subset = (DPLURAL != "5 Quintuplet or higher")
       )

As you can see from above figure, the distribution of birth weights is not quite normal.

As another example, let’s look at real estate prices in San Francisco in 2008 and 2009. This data set is included in the nutshell package as sanfrancisco.home.sales.

• Show the difference of the distribution of real estate prices and normal distribution

# Figure 20
library(nutshell)
data(sanfrancisco.home.sales)
qqmath(~price, data = sanfrancisco.home.sales)

As expected, real estate prices is not normally distributed. Intuitively, it doesn’t make sense for real estate prices to be normally distributed. There are far more people with below-average incomes than above-average incomes. The lowest recorded price in the data set is $100,000; the highest is $9,500,000.

But it looks exponential, so let’s try a log transform.

• Determine whether log-transformed data is normally distributed or not:

# Figure 21
qqmath(~log(price), data = sanfrancisco.home.sales)

A log transform yields a distribution that looks pretty close to normally distributed.

Then let’s take a look at how the distribution changes based on the number of bedrooms.

• Plot smooth lines (type = "smooth") to show how the distribution changes based on the number of bedrooms (groups = bedrooms):

# Figure 22
qqmath(~log(price), 
       groups   = bedrooms, 
       data     = subset(sanfrancisco.home.sales, 
                         !is.na(bedrooms) & bedrooms>0 & bedrooms<7), 
       auto.key = TRUE, 
       drop.unused.levels = TRUE, 
       type     = "smooth"
       )

In this formula, we pass an explicit subset as an argument to the function instead of using the subset argument. Notice that the lines are separate, with higher values for higher numbers of bedrooms. drop.unused.levels is a logical flag indicating whether the unused levels of factors will be dropped.

We can do the same thing for square footage.

• Show how the distribution changes based on square footage.

# Figure 23
# library(Hmisc)
qqmath(~log(price), 
       groups   = cut2(squarefeet, g = 6), 
       data     = subset(sanfrancisco.home.sales, !is.na(squarefeet)), 
       auto.key = TRUE, 
       drop.unused.levels = TRUE, 
       type     = "smooth"
       )

The function cut2 from the package HMisc to divide square footages into six even quantiles.

1.2.2.1 Scatter plots

As an example of a scatter plot, let’s take a look at the relationship between house size and price.

• Show size and price:

# Figure 24
xyplot(price~squarefeet, data = sanfrancisco.home.sales)

It looks like there is a rough correspondence between size and price (the plot looks vaguely cone shaped). Let’s analyze it further.

• Show how this relationship varies by zip code. Trim outliers (sales prices over 4,000,000 and properties over 6,000 square feet) using the subset argument.

table(subset(sanfrancisco.home.sales, !is.na(squarefeet), select = zip))

## 
## 94100 94102 94103 94104 94105 94107 94108 94109 94110 94111 94112 94114 
##     2    52    62     4    44   147    21   115   161    12   192   143 
## 94115 94116 94117 94118 94121 94122 94123 94124 94127 94131 94132 94133 
##   101   124   114    92    92   131    71    85   108   136    82    47 
## 94134 94158 
##   105    13

# Figure 25
xyplot(price~squarefeet|zip, 
       data = sanfrancisco.home.sales, 
       subset = (zip!=94100 & zip!=94104 & zip!=94108 & zip!=94111 & 
                 zip!=94133 & zip!=94158 & price<4000000 & 
                 ifelse(is.na(squarefeet), FALSE, squarefeet<6000)), 
       strip = strip.custom(strip.levels = TRUE)
       )

The first formula is to pick a subset of zip codes to plot. A few parts of the city are sparsely populated (like the financial district, 94104) and don’t have enough data to make plotting interesting. strip.custom() is the function that draws the strips by specifying certain arguments. strip.levels() is a logical vector of length 2, indicating whether or not the level of the conditioning variable is to be written on the strip.

Now, the linear relationship is much more pronounced. We can notice that the different slopes in different neighborhoods. We can make this slightly more readable by using neighborhood names.

• Rerun the code, conditioning by neighborhood. Add a diagonal line to each plot (through a custom panel function). Change the default points plotted to be solid (pch = 19) and shrink them to a smaller size (cex=.2):

# Figure 26
dollars.per.squarefoot <- mean(
  sanfrancisco.home.sales$price / sanfrancisco.home.sales$squarefeet,
  na.rm = TRUE)
xyplot(price~squarefeet|neighborhood,
       data   = sanfrancisco.home.sales,
       pch    = 19,
       cex    = .2,
       subset = (zip!=94100 & zip!=94104 & zip!=94108 & zip!=94111 & 
                 zip!=94133 & zip!=94158 & price<4000000 & 
                 ifelse(is.na(squarefeet), FALSE, squarefeet<6000)),
       strip  = strip.custom(strip.levels   = TRUE,
                             horizontal     = TRUE,
                             par.strip.text = list(cex = .8)),
       panel  = function(...) {panel.abline(a = 0, b = dollars.per.squarefoot)
                               panel.xyplot(...)}
       )

1.2.2.2 Box plots

Box plots in the lattice package are just like box plots drawn with the graphics package. The boxes represent prices from the 25th through the 75th percentiles (the interquartile range), the dots represent median prices, and the whiskers represent the minimum or maximum values. (When there are values that stretch beyond 1.5 times the length of the interquartile range, the whiskers are truncated at those extremes.)

Let’s take a look at how the San Francisco home prices changed over time. We can use box plots to watch how the whole distribution changed in this period.

• Show the distribution of sales prices by month

# Figure 27
table(cut(sanfrancisco.home.sales$date, "month"))

## 
## 2008-02-01 2008-03-01 2008-04-01 2008-05-01 2008-06-01 2008-07-01 
##        139        230        267        253        237        198 
## 2008-08-01 2008-09-01 2008-10-01 2008-11-01 2008-12-01 2009-01-01 
##        253        223        272        118        181        114 
## 2009-02-01 2009-03-01 2009-04-01 2009-05-01 2009-06-01 2009-07-01 
##        123        142        116        180        150         85

bwplot(price~cut(date, "month"), data = sanfrancisco.home.sales)

Unfortunately, this doesn’t produce an easily readable plot and there are a large number of outliers that are making the plot hard to see. Let’s try plotting the box plots again, this time with the logtransformed values. To make it more readable, we can change to vertical box plots and rotate the text at the bottom:

# Figure 28
bwplot(log(price)~cut(date, "month"),
       data   = sanfrancisco.home.sales,
       scales = list(x = list(rot = 90))
       )

we can more clearly see some trends in this plot. Median prices moved around a little during this period, though the interquartile range moved a lot. Moreover, the basic distribution appears pretty stable from month to month.

1.2.2.3 Scatter plots matrices

If you would like to generate a matrix of scatter plots for many different pairs of variables, you can use the splom function.

• Show the relationships between four variables in the iris data set, splited by species. (you will see 16 subgraphs)

head(iris)

# Figure 29
super.sym <- trellis.par.get("superpose.symbol")
splom(~iris[1:4], groups = Species, data = iris,
      panel = panel.superpose,
      key   = list(title   = "Three Varieties of Iris",
                   columns = 3, 
                   points  = list(pch = super.sym$pch[1:3],
                   col     = super.sym$col[1:3]),
                   text    = list(c("Setosa", "Versicolor", "Virginica")))
      )

1.2.2.4 Bivariate quantile-quantile plots

If you would like to generate quantile-quantile plots for comparing two distributions, you can use the function qq.

• Compare two distributions of “Bass 2” and “Tenor 1”.

# library(lattice)
head(singer)

# Figure 30
qq(voice.part ~ height, 
   data   = singer,
   aspect = 1,
   subset = (voice.part == "Bass 2" | voice.part == "Tenor 1")
   )

aspect = 1 means the length of the x-axis is equal to that of the y-axis. As we can see, there’s a little difference between two distributions because the plotted points don’t form a straight diagonal line.

1.2.3.1 Level plots

levelplot function can plot three-dimensional data in flat grids, with colors showing different values for the third dimension. As an example of level plots, we also look at the San Francisco home sales data set.

• Show the number of home sales in different parts of the city. You can use that coordinate data in the San Francisco home sales data set.

# Figure 31
attach(sanfrancisco.home.sales)
levelplot(table(cut(longitude, breaks = 40), cut(latitude, breaks = 40)),
          scales = list(y = list(cex = .5), x = list(rot = 90, cex = .5)),
          xlab   = "latitude",
          ylab   = "longitude"
          )

The table and cut functions are to break the longitude and latitude data into bins and count the number of homes within each bin. xlab and ylab function is a character or expression (or a “grob”) giving label(s) for the x-axis and y-axis.

If we were interested in looking at the average sales price by area, we could use a similar strategy. Instead of table, you can use the tapply function to aggregate observations.

# Figure 32
levelplot(tapply(price, 
                 INDEX = list(cut(longitude, breaks = 40), cut(latitude, breaks = 40)),
                 FUN   = mean),
          scales = list(draw = FALSE),
          xlab = "latitude",
          ylab = "longitude"
          )

scales is generally a list determining how the x- and y-axes (tick marks and labels) are drawn. draw is a logical flag, determines whether to draw the axis (i.e., tick marks and labels) at all.

Of course, you can use conditioning values with level plots.

• Show the number of home sales, by numbers of one and two bedrooms. Simplify the data slightly by looking at houses with zero to four bedrooms and then houses with five bedrooms or more.

# Figure 33
bedrooms.capped <- ifelse(bedrooms<5, bedrooms, 5)
levelplot(table(cut(longitude, breaks = 25),cut(latitude, breaks = 25), bedrooms.capped),
          scales = list(draw = FALSE)
          )

1.2.3.2 Contour plots

contourplot function is to to show contour plots with lattice (which resemble topographic maps). We can use ?contourplot to see more details.

• A simple example:

# Figure 34
contourplot(volcano)

1.2.3.3 Cloud plots

cloud function is to plot points in three dimensions (technically, projections into two dimensions of the points in three dimensions). You can use ?cloud to see more details. The data set volcano is package datasets.

• A simple example:

# Figure 35
cloud(volcano, zlab = list("volcano", rot = 90))

1.2.3.4 Wire-frame plots

If you would like to show a three-dimensional surface, you could use the function wireframe.

• A simple example:

# Figure 36
wireframe(volcano, zlab = list("volcano", rot = 90))

1.2.5.1 Common Arguments to Lattice Functions

Lattice functions share many common arguments. Instead of explaining what each function does separately we’ll explain them in a single table.

If you would like to get more information about augments, see the help files.

1.2.5.2 Controlling How Axes Are Drawn

You can control how axes are drawn in the lattice package by named values in the argument scales. Here is a table of the available arguments.

For more details on other arguments, you can see the page 310 of the book R IN A NUTSHELL.

1.2.5.3 Parameters

In the graphics package, we use par function to set or query default parameters.

• Check the value of the parameter cex:

par("cex")

## [1] 1

That is a similar mechanism for lattice graphics. To check the value of a setting, use the function trellis.par.get. To change a setting, use the function trellis.par.set

• Check the values of the axis.text parameter, which controls the look of text printed on axes:

trellis.par.get("axis.text")

## $alpha
## [1] 1
## 
## $cex
## [1] 0.8
## 
## $col
## [1] "#000000"
## 
## $font
## [1] 1
## 
## $lineheight
## [1] 1

• Change the parameter axis.text$cex to 0.5

trellis.par.set(list(axis.text = list(cex = 0.5)))

• Show a list of all settings:

show.settings()

We can also use trellis.par.get().

names(trellis.par.get())

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

There are 35 highlevel groups of parameters describing how different components are drawn. If you want to know details of what each of these groups of parameters control, please refer to page 313 of the book “R in a nutshell”.

1.2.5.4 plot.trellis

As we noted above, lattice functions do not plot results; they return lattice objects. To plot a lattice object, you need to call print.trellis() or plot.trellis() on the lattice object. It’s possible to control how lattice objects are printed through changing arguments of them.

• Get the list of arguments for plot.trellis()

?plot.trellis

1.2.5.5 strip.default

To change the way strips are drawn, you can specify your own strip function as an argument to a lattice function. The simplest way to modify the appearance of the strips is by using the function strip.custom. This function accepts the same arguments as strip.default and returns a new function that can be specified as an argument to a lattice function. We have used this function when ploting Figure 25.

• Get the list of arguments for plot.trellis

?strip.default

2.2.4.1 Adding a Smoother to a Plot

• Add a smoothed line to the scatterplot:

# Figure 5
ggplot(mpg, aes(displ, hwy)) +
  geom_point() +
  geom_smooth()

This overlays the scatterplot with a smooth curve, including an assessment of uncertainty in the form of point-wise confidence intervals shown in grey. If you’re not interested in the confidence interval, turn it off with geom_smooth(se = FALSE).

An important argument to geom_smooth() is the method, which allows us to choose which type of model is used to fit the smooth curve:

• method = "loess", the default for small $n$, uses a smooth local regression. The wiggliness of the line is controlled by the span parameter, which ranges from 0 (exceedingly wiggly) to 1 (not so wiggly). Notice that loess does not work well for large datasets (n > 1,000).

# Figure 6
ggplot(mpg, aes(displ, hwy)) +
  geom_point() +
  geom_smooth(span = 0.2)

• method = "gam" fits a generalised additive model provided by the mgcv package. You need to first load mgcv, then use a formula like formula = y ~ s(x) or y ~ s(x, bs = "cs") (for large data). This is what ggplot2 uses when there are more than 1,000 points.

# Figure 7
library(mgcv)
ggplot(mpg, aes(displ, hwy)) +
  geom_point() +
  geom_smooth(method = "gam", formula = y ~ s(x))

• method = "lm" fits a linear model, giving the line of best fit.

# Figure 8
ggplot(mpg, aes(displ, hwy)) +
  geom_point() +
  geom_smooth(method = "lm")

2.2.4.2 Boxplots and Jittered Points

When a set of data includes a categorical variable and one or more continuous variables, you will probably be interested to know how the values of the continuous variables vary with the levels of the categorical variable.

• See how fuel economy varies within car class

# Figure 9
ggplot(mpg, aes(drv, hwy)) +
  geom_point()

Because there are few unique values of both class and hwy, there is a lot of overplotting. Many points are plotted in the same location, and it’s difficult to see the distribution. There are three useful techniques that help alleviate the problem:

• Jittering, geom_jitter(), adds a little random noise to the data which can help avoid overplotting.

# Figure 10
ggplot(mpg, aes(drv, hwy)) + 
  geom_jitter()

• Boxplots, geom_boxplot(), summarise the shape of the distribution with a handful of summary statistics.

# Figure 11
ggplot(mpg, aes(drv, hwy)) + 
  geom_boxplot()

• Violin plots, geom_violin(), show a compact representation of the density of the distribution, highlighting the areas where more points are found.

# Figure 12
ggplot(mpg, aes(drv, hwy)) + 
  geom_violin()

2.2.4.3 Histograms and Frequency Polygons

Histograms and frequency polygons show the distribution of a single numeric variable. They provide more information about the distribution of a single group than boxplots do, at the expense of needing more space.

# Figure 13
ggplot(mpg, aes(hwy)) + 
  geom_histogram()

# Figure 14
ggplot(mpg, aes(hwy)) + 
  geom_freqpoly()

Both of them bin the data, then count the number of observations in each bin. The only difference is the display: histograms use bars and frequency polygons use lines. However, the default just splits your data into 30 bins, which is unlikely to be the best choice.

• Change the width of the bins with the binwidth argument:

# Figure 15
ggplot(mpg, aes(hwy)) +
  geom_freqpoly(binwidth = 2.5)

• Use factting:

# Figure 16
ggplot(mpg, aes(displ, fill = drv)) +
  geom_histogram(binwidth = 0.5) +
  facet_wrap(~drv, ncol = 1)

2.2.4.4 Bar Charts

The discrete analogue of the histogram is the bar chart, geom_bar().

• Plot a bar chart

# Figure 17
ggplot(mpg, aes(manufacturer)) +
  geom_bar(aes(fill = drv))

2.2.4.5 Time Series with Line and Path Plots

Line and path plots are typically used for time series data. Line plots join the points from left to right, while path plots join them in the order that they appear in the dataset. Line plots usually have time on the x-axis, showing how a single variable has changed over time. Path plots show how two variables have simultaneously changed over time, with time encoded in the way that observations are connected.

We’ll show some time series plots using the economics dataset, which contains economic data on the US measured over the last 40 years.

• Show how the unemployment rate change over these years.

# Figure 18
ggplot(economics, aes(date, unemploy / pop)) +
  geom_line()

Now we would like to examine the relationship between unemployment rate and length of unemployment. Meanwhile, we also need to see the evolution over time. The solution is to join points adjacent in time with line segments, forming a path plot.

• Show the relationship between unemployment rate and length of unemployment in each year.

# Figure 19
ggplot(economics, aes(unemploy / pop, uempmed)) +
  geom_path(colour = "grey50") +
  geom_point(aes(colour = date))

In the plot, we colour the points to make it easier to see the direction of time. Pay attention to the difference of geom_point(colour = ...) and geom_point(aes(colour = ...)).

2.3.4.1 Name

The first argument to the scale function, name, is the axes/legend title. You can supply text strings (using \n for line breaks) or mathematical expressions in quote()

# Figure 40
df <- data.frame(x = 1:2, y = 1, z = "a")
ggplot(df, aes(x, y)) + 
  geom_point() +
  scale_x_continuous(quote(a + mathematical ^ expression))

Because tweaking these labels is such a common task, there are three helpers that save you some typing:xlab(), ylab() and labs():

# Figure 41
ggplot(df, aes(x, y)) + geom_point(aes(colour = z)) +
  labs(x = "X axis", y = "Y axis", colour = "Colour\nlegend")

There are two ways to remove the axis label.

1. labs(x = "", y = "") : omits the label, but still allocates space;
2. labs(x = NULL, y = NULL): removes the label and its space.

2.3.4.2 Breaks and Labels

The breaks argument controls which values appear as tick marks on axes and keys on legends. Each break has an associated label, controlled by the labels argument. If you set labels, you must also set breaks; otherwise, if data changes, the breaks will no longer align with the labels.

# Figure 42
df <- data.frame(x = c(1, 3, 5) * 1000, y = 0.5)
ggplot(df, aes(x, y)) +
  geom_point() +
  labs(x = NULL, y = NULL) +
  scale_x_continuous(breaks = c(2000, 4000), labels = c("2k", "4k")) +
  scale_y_continuous(breaks = c(0.25, 0.75), labels = c("25%", "75%"))

The scales package provides a number of useful labelling functions:

1. scales::comma_format() adds commas to make it easier to read large numbers.

2. scales::unit_format(unit, scale) adds a unit suffix, optionally scaling.

3. scales::dollar_format(prefix, suffix) displays currency values, rounding to two decimal places and adding a prefix or suffix.

4. scales::wrap_format() wraps long labels into multiple lines.

# Figure 43
df <- data.frame(x = c(1, 3, 5) * 1000, y = 0.5)
ggplot(df, aes(x, y)) +  geom_point() +  labs(x = NULL, y = NULL) + 
  scale_y_continuous(labels = scales:::dollar_format(prefix="$"))

You can adjust the minor breaks (the faint grid lines that appear between the major grid lines) by supplying a numeric vector of positions to the minor_breaks argument. This is particularly useful for log scales:

# Figure 44
df <- data.frame(x = c(2, 3, 5, 10, 200, 3000), y = 1)
mb <- as.numeric(1:10 %o% 10 ^ (0:4))
ggplot(df, aes(x, y)) +
  geom_point() +
  scale_x_log10(minor_breaks = mb)

2.3.7.1 Legend Elements

The legend elements control the apperance of all legends. We can also modify the appearance of individual legends by modifying these elements.

# Figure 56
df <- data.frame(x = rnorm(300), y = rnorm(300))
df$z <- cut(df$x, 6, labels = c("a", "b", "c", "d", "e", "f"))
ggplot(df, aes(x, y)) + 
  geom_point(aes(colour = z, shape = z), size = 2) +
  theme_minimal() +
  scale_colour_brewer(type = "seq", palette = "Dark2") +
  theme(legend.key = element_rect(color = "grey50"),
        legend.key.width = unit(0.9, "cm"),
        legend.key.height = unit(0.75, "cm"),
        legend.text = element_text(size = 15),
        legend.title = element_text(size = 15, face = "bold"),
        legend.title.align = 0.3)

2.3.7.2 Panel Elements

Panel elements control the appearance of the plotting panels. You can also modify the appearance of panel by modifying these elements.

# Figure 57
df <- data.frame(x = rnorm(300), y = rnorm(300))
df$z <- cut(df$x, 6, labels = c("a", "b", "c", "d", "e", "f"))
ggplot(df, aes(x, y)) + 
  geom_point(aes(colour = z, shape = z), size = 2) +
  theme_linedraw() +
  scale_colour_brewer(type = "seq", palette = "Dark2") +
  theme(panel.background = element_rect(fill = "#C7EAE5"),
        panel.grid.major.x = element_line(color = "gray60", size = 0.8),
        plot.background = element_rect(colour = "black", size = 2),
        aspect.ratio = 12 / 16)

2.3.7.3 Facetting Elements

The above theme elements are associated with faceted ggplots.

# Figure 58
df <- data.frame(x = rnorm(300), y = rnorm(300))
df$z <- cut(df$x, 6, labels = c("a", "b", "c", "d", "e", "f"))
ggplot(df, aes(x, y)) + 
  geom_point(aes(colour = z, shape = z), alpha = 0.7) +
  theme_linedraw() +
  scale_colour_brewer(type = "seq", palette = "Dark2") +
  facet_wrap(~z) +
  theme(panel.spacing = unit(0.5, "in"),
        strip.background = element_rect(fill = "grey20", color = "grey80", size = 1),
        strip.text = element_text(colour = "white"))

2.3.8.1 Key Color Functions

First, let’ s see some key ggplot2 R functions for changing a plot color.

1. Set ggplot color manually:

• scale_fill_manual() for box plot, bar plot, violin plot, dot plot, etc

• scale_color_manual() or scale_colour_manual() for lines and points

2. Use colorbrewer palettes:

• scale_fill_brewer() for box plot, bar plot, violin plot, dot plot, etc
• scale_color_brewer() or scale_colour_brewer() for lines and points

3. Use grey color scales:

• scale_fill_grey() for box plot, bar plot, violin plot, dot plot, etc

• scale_colour_grey() or scale_colour_brewer() for points, lines, etc

4. Change the default ggplot gradient color:

• scale_color_gradient(), scale_fill_gradient() for sequential gradients between two colors

• scale_color_gradient2(), scale_fill_gradient2() for diverging gradients

• scale_color_gradientn(), scale_fill_gradientn() for gradient between n colors

This is the default color:

# Figure 59
ggplot(diamonds, aes(carat, price, colour = cut)) +
  geom_point(size = 0.5)

Set custom color palettes:

# Figure 60
ggplot(diamonds, aes(carat, price, colour = cut)) +
  geom_point(size = 0.5) +
  scale_colour_manual(values = c("#6794a7", "#014d64", "#7ad2f6", "#01a2d9", "#76c0c1"))

Using palette in RColorBrewer:

# Figure 61
library(RColorBrewer)
ggplot(diamonds, aes(carat, price, colour = cut)) +
  geom_point(size = 0.5) +
  scale_colour_brewer(palette = "Greens")

Using grey color scales:

# Figure 62
ggplot(diamonds, aes(carat, price, colour = cut)) +
  geom_point(size = 0.5) +
  scale_colour_grey()

When data is splitted by a continuous variable:

Sequential gradients between two colors

# Figure 63
ggplot(diamonds, aes(carat, price, colour = depth)) +
  geom_point(size = 0.5)+
  scale_colour_gradient(low = "orange", high = "Darkred")

Diverge gradients

# Figure 64
ggplot(diamonds, aes(carat, price, colour = depth)) +
  geom_point(size = 0.5) +
  scale_colour_gradient2(low="#8E0F2E", mid="#BFBEBE", high="#0E4E75")

2.3.8.2 Predefined Color Palettes in RColorBrewer and ggplot2

Second, we’ll see some predefined color palettes in R package. The most commonly used color scales are Colorbrewer palettes [RColorBrewer package] and Grey color palettes [ggplot2 package].

• Show all colorbrewer palettes in RColorBrewer package:

display.brewer.all(colorblindFriendly = TRUE) will display only colorblind friendly palettes.

• Visualize a single RColorBrewer palette by specifying its name:

# Figure 65
display.brewer.pal(11, "Spectral")

• Return the hexadecimal color code of the palette:

brewer.pal(11, "Spectral")

##  [1] "#9E0142" "#D53E4F" "#F46D43" "#FDAE61" "#FEE08B" "#FFFFBF" "#E6F598"
##  [8] "#ABDDA4" "#66C2A5" "#3288BD" "#5E4FA2"

2.3.8.3 Predefined Color in R

Then, there are five predefined color palettes and 657 built-in color names available in R.

show_col() in scales package will give you a quick and dirty way to show colours in a plot.

# Figure 66
library(scales)
show_col(rainbow(16), labels = T)

# Figure 67
ggplot(diamonds, aes(carat, price, colour = cut)) +
  geom_point(size = 0.5) +
  scale_colour_manual(values = rainbow(25))

Because cut has 5 factors, in values = rainbow(n), n must be greater than or equal to 5. values takes the first five values. Change n and you will get different beautiful plots.

The function colors() returns the color names, which R knows about.

# Figure 68
r_color <- colors()
head(r_color)

## [1] "white"         "aliceblue"     "antiquewhite"  "antiquewhite1"
## [5] "antiquewhite2" "antiquewhite3"

# Figure 69
show_col(r_color, labels = FALSE, border = "white")

2.3.8.4 Other Color Schemes

Finally, ggthemes package provides a large number of high-quality themes and color schemes. The most common schemes are economist, wsj, stata, excel, tableau and solarized.

library(ggthemes)
m<-excel_pal()(6)
show_col(m)

# Figure 70
ggplot(diamonds, aes(carat, price, colour = cut)) +
  geom_point(size = 0.5) +
  scale_colour_excel() 

The R package ggsci also contains a collection of high-quality color palettes inspired by colors used in scientific journals, data visualization libraries, and more. The color palettes are provided as ggplot2 scale functions:

• scale_color_npg() and scale_fill_npg(): Nature Publishing Group color palettes

• scale_color_aaas() and scale_fill_aaas(): American Association for the Advancement of Science color palettes

• scale_color_lancet() and scale_fill_lancet(): Lancet journal color palettes

• scale_color_jco() and scale_fill_jco(): Journal of Clinical Oncology color palettes

• scale_color_tron() and scale_fill_tron(): This palette is inspired by the colors used in Tron Legacy. It is suitable for displaying data when using a dark theme.

You can find more examples in the ggsci package vignettes.