3.2.1 Labels/ titles

The first argument to the scale function, name, is the axes/legend title:

ggplot(mpg, aes(displ, hwy)) + 
  geom_point(aes(colour = class)) + 
  scale_x_continuous("This is my label \n for the x-axis") +
  scale_y_continuous("Hello World!")

As you will do this quite ofte, people have already produced shortcuts for you: xlab(), ylab() and labs().

my_plot <- ggplot(mpg, aes(displ, hwy)) + geom_point(aes(colour = class))
my_plot + 
  xlab("My first X axis") + 
  ylab("My first Y axis")
my_plot + labs(x = "My second X axis", y = "My second Y axis", colour = "My own\nlegend")

To remove axis labels, you have to set x or y = NULL. If you set them = "", you will produce an empty space instead of removing the label.

3.2.2 Breaks/ 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.

my_plot
my_plot + scale_x_continuous(breaks = c(2, 4, 6))
my_plot + scale_x_continuous(breaks = c(2, 4, 6), labels = c("two", "four", "Got'ya"))

Same with legend breaks:

my_plot
my_plot + scale_colour_continuous(breaks = c(15, 30))
my_plot + scale_colour_continuous(breaks = c(15, 30), labels = c("low", "high"))

3.4.1 Continuous

Colour gradients are often used to show the height of a 2d surface. In the following example we’ll use the surface of a 2d density estimate of the faithful dataset (Azzalini and Bowman 1990, within the ggplot2 package), which records the waiting time between eruptions and during each eruption for the Old Faithful geyser in Yellowstone Park. I hide the legends and set expand to 0, to focus on the appearance of the data. This expands to plot to allign with the axis lines, instead of having some space there by default.

erupt <- ggplot(faithfuld, aes(waiting, eruptions, fill = density)) +
  geom_raster() +
  scale_x_continuous(NULL, expand = c(0, 0)) + 
  scale_y_continuous(NULL, expand = c(0, 0)) + 
  theme(legend.position = "none")

There are four continuous colour scales:

• scale_colour_gradient() and scale_fill_gradient(): a two-colour gradient, low-high (light blue-dark blue). This is the default scale for continuous colour, and is the same as scale_colour_continuous(). Arguments low and high control the colours at either end of the gradient.

erupt

erupt + scale_fill_gradient(low = "white", high = "black")

• scale_colour_gradient2() and scale_fill_gradient2(): a three-colour gradient, low-med-high (default is red-white-blue). As well as low and high colours, these scales also have a mid colour for the colour of the midpoint. The midpoint defaults to 0, but can be set to any value with the midpoint argument.

mid <- median(faithfuld$density)
erupt + scale_fill_gradient2(midpoint = mid, low = "darkred", mid = "darkgreen", 
                             high = "darkblue") 

• scale_colour_gradientn() and scale_fill_gradientn(): a custom n-colour gradient. This is useful if you have colours that are meaningful for your data (just ask Nussaibah about her terrain map), or you’d like to use a palette produced by another package (like colorspace or RColorBrewer).

erupt + scale_fill_gradientn(colours = terrain.colors(7))
erupt + scale_fill_gradientn(colours = colorspace::heat_hcl(7))
erupt + scale_fill_gradientn(colours =  RColorBrewer::brewer.pal(7, "Spectral"))

• scale_color_distiller() and scale_fill_distiller() apply the ColorBrewer colour scales to continuous data. You use it the same way as scale_fill_brewer(), described later.

erupt + scale_fill_distiller()
erupt + scale_fill_distiller(palette = "RdPu")
erupt + scale_fill_distiller(palette = "YlOrBr")

3.4.2 Discrete

There are four colour scales for discrete data:

• The default colour scheme, scale_colour_hue(), picks evenly spaced hues around the HCL colour wheel. This works well for up to about eight colours, but after that it becomes hard to tell the different colours apart. You can control the default chroma and luminance, and the range of hues, with the h, c and l arguments:

my_bars
my_bars + scale_fill_hue(c = 40)
my_bars + scale_fill_hue(h = c(180, 300))

• scale_colour_brewer() uses handpicked ColorBrewer colours, from the RColorBrewer package. These colours have been designed to work well in a wide variety of situations, although the focus is on maps and so the colours tend to work better when displayed in large areas.

• scale_colour_grey() maps discrete data to grays, from light to dark.

• scale_colour_manual() is useful if you have your own discrete colour palette. You can even use them with colours inspired by Wes Anderson movies, as provided by the wesanderson package.
  Instead of mapping a colour palette to your data, you can use the values parameter of scale_colour_manual() (or scale_fill_manual(), depending on your aesthetics) to manually specify the values that the scale should produce:

my_plot + scale_colour_manual(values = wesanderson::wes_palette("BottleRocket1"))

my_bars + 
  scale_fill_manual(values = c("coral", "orange", "darkgreen", "steelblue", "#ba855e", "#919108", "#f25ad8"))

You can steel colours from your favourite artist using the colortheft webpage.
Like I already mentioned, it is always important to think about what you want to visualise and what message you want to convey. There is not the one colour palette to fit all your needs, play around with them and see what fits. Also: bright colours work well for points, but are overwhelming on bars. Subtle colours work well for bars, but are hard to see on points.

5.1.1 Zooming

You can use coord_cartesian() to zoom into a plot. You might be tempted to zoom into a plot using scale limits, but this is not a good idea: When setting scale limits, any data outside the limits is thrown away; but when setting coordinate system limits we still use all the data, but we only display a small region of the plot. Setting coordinate system limits is like looking at the plot under a magnifying glass.

my_reg <- ggplot(mpg, aes(displ, hwy)) +
  geom_smooth(method = "lm") 
my_reg + labs(title ="Raw plot")
my_reg + labs(title = "Wrong zooming") + scale_y_continuous(limits = c(20,30))

## Warning: Removed 100 rows containing non-finite values (stat_smooth).

my_reg + labs(title = "Correct zooming") + coord_cartesian(ylim = c(20,30))

5.1.2 Axis flipping

If you want to rotate the plot 90 degrees, you can use coord_flip() to exchange the x and y axes. Compare this with just exchanging the variables mapped to x and y:

ggplot(mpg, aes(displ, cty)) + 
  geom_point() + 
  geom_smooth()
# Exchanging cty and displ rotates the plot 90 degrees, but the smooth 
# is fit to the rotated data.
ggplot(mpg, aes(cty, displ)) + 
  geom_point() + 
  geom_smooth()
# coord_flip() fits the smooth to the original data, and then rotates 
# the output
ggplot(mpg, aes(displ, cty)) + 
  geom_point() + 
  geom_smooth() + 
  coord_flip()

5.1.3 Equal scales

coord_fixed() fixes the ratio of length on the x and y axes. The default ratio ensures that the x and y axes have equal scales: i.e., 1 cm along the x axis represents the same range of data as 1 cm along the y axis. The aspect ratio will also be set to ensure that the mapping is maintained regardless of the shape of the output device. See the documentation of coord_fixed() for more details.

5.2.1 Polar coordinates

Using polar coordinates gives rise to pie charts and wind roses (from bar geoms), and radar charts (from line geoms). The code below shows how we can turn a bar into a pie chart or a bullseye chart by changing the coordinate system.

base <- ggplot(mtcars, aes(factor(1), fill = factor(cyl))) +
  geom_bar(width = 1) + 
  theme(legend.position = "none") + 
  scale_x_discrete(NULL, expand = c(0, 0)) +
  scale_y_continuous(NULL, expand = c(0, 0))

# Stacked barchart
base

# Pie chart
base + coord_polar(theta = "y")

# The bullseye chart
base + coord_polar()

5.2.2 Map projections

Maps are intrinsically displays of spherical data. Simply plotting raw longitudes and latitudes is misleading, so we must project the data. There are two ways to do this with ggplot2:

• coord_quickmap() is a quick and dirty approximation that sets the aspect ratio to ensure that 1m of latitude and 1m of longitude are the same distance in the middle of the plot. This is a reasonable place to start for smaller regions, and is very fast.

# Prepare a map of italy
itmap <- ggplot(map_data("italy"), aes(long, lat, group = group)) +
  geom_polygon(fill = "white", colour = "black") +
  xlab(NULL) + ylab(NULL)

# Plot it in cartesian coordinates
itmap
# With the aspect ratio approximation
itmap + coord_quickmap()

• coord_map() uses the mapproj package, https://cran.r-project.org/package=mapproj to do a formal map projection. It takes the same arguments as mapproj::mapproject() for controlling the projection. It is much slower than coord_quickmap() because it must munch the data and transform each piece. Normally coord_quickmap() should be sufficient.