Aesthetics

Our plot above, created by ggplot(mtcars, aes(wt, mpg)), included aesthetic mappings for our two variables car weight and miles per gallon. The mapping provided by aes(x, y) is bar far the most important part of aesthetics, but it is also the easiest. In most common use cases of ggplot2 the (x, y) portion of the code simply refers to our x and y variables—two things we should already know! We will start adding other aesthetics as we move along but these are absolutely key.

A Note on Coding Style for ggplot2

Before moving further, I want to make sure that the code structure is clearly understood. Experienced R users (or otherwise experienced programmers) will likely struggle with this far less than I did for the longest time. Let’s first look at the core aspects of the ggplot() code structure:

ggplot(data = data, mapping = aes(x = x, y = y, ...), ...)

The first part of what we see here is the ggplot() function itself. The second data, x, and y in this case all refer to those in our data. Inside the outer set of parentheses we first point the plotting function to our data (this needs to be an R dataframe that is available in the workspace—or it can be a tibble). This is the first place where we see major variations in code. Some people will leave off the data = part and just type the name of the data object as a shortcut. I do this as well, but it can be confusing for folks new to ggplot2. The next block is for mapping our aesthetics. We rarely see the mapping = part of the code, and we can again just shortcut things by using aes(). Within the aes() parentheses, we then map our x and y variables by following the same convention. That is, we either say aes(x = x, y = y) or simply aes(x, y). Most of the remaining parts of the function typically need to specific, if for nothing else human readability. We will get to those later.

The next place we see major variation in code is whether folks assign their plot to an object or just run the code outright. This is not a huge distinction for actually making a plot when using well-structured code, but how we read the code certainly changes. Since R is an object-oriented programming language we can assign the whole plot to an object just like we can a dataset, variable, function, etc. The best way to see how this works is with an example. Returning to where we were above, we could instead assign our blank plot to an object called “p.” Why “p?” No reason other than it is most commonly used in these cases. You could call it “plot,” or anything you like as long as it adheres to R’s object naming standards (Wickham (2019)).

p <- ggplot(mtcars, aes(wt, mpg))

Now, using R’s object assignment operator, <-, we have assigned our plot to the object called “p.” But notice also that the plot did not automatically return. To get that we need to simply ask R for it using the object name.

p

Now, where things get sometimes confusing, and this is jumping ahead, is when folks add additional layers to the plot. If we wanted to see some points on the plot with our initial code above we could do this:

ggplot(mtcars, aes(wt, mpg)) +
  geom_point()

Notice that we do this by adding a + (telling ggplot() there is a new layer incoming) and then we type the new code. I like to put each new layer on its own line and indent a little after the first line. That helps human readability and allows us to root out bugs in the code. Using the object method we could do something similar.

p <- ggplot(mtcars, aes(wt, mpg))
p + geom_point()

Can you see any issue with this approach? It does work, but in my mind using the object + method is somewhat void of utility (short of some type of exhibition of functionality for vignettes) given that to get the new layer we have to call the object and the new layer together. What if, though, we reassigned the new layer to our object like this?

p <- ggplot(mtcars, aes(wt, mpg))
p <- p + geom_point()

Now, the new geom_point() layer is also assigned to p and when we call p we should get it all:

p

There are uses to this approach, but it needs to be thought through. It makes reading the code a bit more difficult, and all of the assignment operators and plus signs can get busy. Keep in mind that you could also create new objects with each layer should that be useful. We will return to this later when I talk about saving our plots, but that should really only be a final step taken with care. For now, just know that when you see something like p <- ggplot(...) you should be able to just return p to get to the same place as you would be by using ggplot(...) directly.

Finally, with the advent of the so-called pipe (%>%) operator from the maggritr package and later dplyr, among others, we will sometimes see folks do this:

mtcars %>% 
  ggplot(aes(wt, mpg))

Indeed, I do this on occasion. Do not be scared off by the code, however, as we are just replacing our ggplot(data = data,…) with data %>% ggplot(...) and thus it is a simple reordering of the code. Since we cannot work with pipes beyond this in ggplot it really just becomes a niche habit and not particularity useful otherwise.³

Geometric Shapes (geom) and Statistical Transformations (stat)

Let’s get back to how to make plots. Our next step is adding geometric shapes and statistical transformations. We had a glimpse at this earlier, but let’s resume with the same plot:

ggplot(mtcars, aes(wt, mpg)) +
  geom_point()

In this case, we have asked ggplot() to add points to the plot and thus we now have a scatterplot. The “geoms” are numerous, and they are the key to what type of plot you end up with whether it be a bar graph, line graph, histogram, or more. See a list here. Let’s add a linear best fit (regression) line to our scatterplot using another geom called geom_smooth().

ggplot(mtcars, aes(wt, mpg)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm)

Note that geom_smooth needs to know what kind of method we are using and the formula for the calculation of the slope. In this case we are using similar syntax to that of base R’s regression model function, lm. Our formula simply tells ggplot() we want to see the relationship denoted by \(y = f(x)\). Notice also that this our first example of layering two geoms on the same plot. This is key to understanding how the ggplot2 system works. If we want to plot points and labels (see below), we first plot the points and then we add a layer of labels that are relative to the points. We do not plot points and label them at the same time like we would in most other graphic implementations. Once you get this, you will begin to think of your plots as a set of layers that can be added or removed based on your needs.

What if we instead wanted a horizontal line in the middle of the scatterplot? Note that this type of geom requires that you know the coordinates of the data you are plotting.

ggplot(mtcars, aes(wt, mpg)) +
  geom_point() +
  geom_abline(intercept = 22.5, slope = 0)

Let’s look at some other options starting with a bar plot. We will start by looking at the number of cars for each number of possible carburetors.

ggplot(mtcars, aes(carb)) + 
  geom_bar() 

We will get back to some more interesting bar plot as this one is akin to a histogram, which we can also easily do since there is a geom for it. Returning to mpg

ggplot(mtcars, aes(mpg)) + 
  geom_histogram(bins = 10) 

Relatedly, we can easily make a density plot:

ggplot(mtcars, aes(mpg)) + 
  geom_density() 

There are many types of geoms, but hopefully now you are getting an idea of how we use them. We will see quite a few more by the time we are done so for now I want to move on to the next basic building block of a plot.

Scales

Scales are used within ggplot2 to determine how the data being plotted looks to those of us reading the plot. I use scales in two primary ways, one to control the colors of the geoms and the other to format the axes. There are more extensions as well, but let’s just focus on these two for now to create an illustrative example.

ggplot(mtcars, aes(wt, mpg, color = carb)) + 
  geom_point() +
  scale_color_continuous()

Notice that first I added to our aesthetics by using color = carb to say I wanted to color the mapped data by the number of carburetors. I think tell ggplot() that we want to treat this as a continuous scale. There are lots of variants to scale_color_... and I will cover at least several of them below. The other way in which I use scales is for axis formatting. Since our x-axis here is measured in thousands it gives us a nice chance to fix things up. Rather than writing something like (in thousands) in the axis title, we can just build some formatting right into our code. A nifty feature of ggplot2 is that we can do mathematical operations on variables right in the plotting function. So, I am going to multiply the wt variable by 1,000.

ggplot(mtcars, aes(wt * 1000, mpg, color = carb)) + 
  geom_point() +
  scale_color_continuous()

That’s much better, and we will work on the axis titles later. We can go further, however, by adding a comma separator. This involves using another package, scales, but we will call it using the :: syntax and thus using library() to explicitly load the package is not necessary.

ggplot(mtcars, aes(wt * 1000, mpg, color = carb)) + 
  geom_point() +
  scale_color_continuous() +
  scale_x_continuous(labels = scales::comma)

Notice here that our additional line of code was scale_x_continuous(labels = scales::comma). With this we are saying we want to rescale the x-axis (we can do y as well.) Then, we are using the labels = option to call the comma formatting from the scales package. This is another really cool use of ggplot2 as we can do similar formatting for percents and currency, for example. Those are two places I see folks really mail it in graphing.⁴

Coordinate Systems

You have probably already noticed that ggplot2 builds graphs on Cartesian coordinates by default, and it explicitly draws a grid of these coordinates thus mapping the x and y aesthetics quite clearly. We can decide whether we need this level of detail for the coordinates later, but for now it is important to understand a few basics. First and foremost, the default is Cartesian and these can be flipped (using the aptly named coord_flip() function) such that x and y swap places. The most basic example is to use our bar plot from above:

ggplot(mtcars, aes(carb)) + 
  geom_bar() +
  coord_flip()

We will get to some nicer examples of flipped plots later, but there is just a bit more to say on coordinates. You can do some basic tweaking of the default coordinates by fixing the aspect ratio (coord_fixed()), projecting maps (coord_map()), or using coord_trans() to do transformations of the coordinates (e.g., logarithms). Finally, all of this may make you wonder how in the world you would make a pie chart using ggplot2. The answer from many (and sometimes me) would be that you shouldn’t. But, if you must, coord_polar is a good place to start.⁵

Facets

Facets are essentially a way of paneling your plot based on different categories or levels of variables. Let’s return to our scatterplot from above for an example that will make things clear. The difference is that this time we will split the observations into two plots, one for manual transmissions (1) and one for automatic (0).

ggplot(mtcars, aes(wt, mpg)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  facet_wrap(vars(am))

There are two types of faceting, facet_grid() and facet_wrap(). In this case they are essentially equivalent but when we get to more categories below we will see the distinction more clearly. In terms of the syntax, much of the older code you will see would instead have something like this facet_wrap(.~am) but the newer versions of the package allow for the cleaner usage of vars(). You can facet by multiple variables if you wish, and you can control many things about how the facets look and are organized. We will have more examples below.

Making Your Plot Look Good

There are many, many opinions on how plots should look. As such, the style we end up with here will mainly be my own preference. Hopefully between this and the next section I can give you the tools you need to make the plots look as you would like them to. This is also where the library of options within ggplot2 explodes, so I am certainly not calling this a comprehensive treatment of plot improvement beyond the default.⁶

Virtually everything about a plot can be changed. We will cover the fundamentals but I am sure some things will be left off. Luckily an online search often points you to a Stack Overflow thread where someone has experienced a similar issue before. Let’s get started with some basics. Most all things we want to change about the look of a plot happens within the theme() function, but the main exception is with the labels for the axes, title, subtitle, and caption. These use the labs function. Let’s see how that works.⁷

ggplot(mtcars, aes(wt, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous() +
  scale_x_continuous(labels = scales::comma) +
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data")

These are fairly easy, just pay attention to the quotation marks and commas. Now, what if we want a better legend title. As with some things in ggplot2 there are multiple routes to get there. I typically just use name = "" inside of the scaling function as follows:

ggplot(mtcars, aes(wt, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) +
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data")

We will deal with many more legend examples as we go along. Before getting into that, however, let me talk about some of the basics in terms of plot styling. As I mentioned above, most of our remaining action here will be inside of the theme() function. One of the original hallmarks of ggplot2 was the grey background in the plotting (panel) area with the white grid lines intersecting on both major and minor grids corresponding with the axis tick labels and halfway between them. That is what we have been seeing so far. Let’s start by changing the background to white.

ggplot(mtcars, aes(wt, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) +
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data") +
  theme(panel.background = element_rect(fill = "#FFFFFF"))

Notice that I started here with theme and then referenced the specific aspect of the theme I wanted to change. panel.background refers to the plotting area. plot.background, on the other hand, refers to the area outside the plot. For example, we could do this to fill in the plot area with A-State red:

ggplot(mtcars, aes(wt, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) +
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data") +
  theme(panel.background = element_rect(fill = "#FFFFFF"), plot.background = element_rect(fill = "#cc092f"))

Notice here that I added the additional theme() option within the same function, but for clarity you could also just have a series of theme functions each on their own line. In any case, you would want to make your code legible as the options can get lengthy quite quickly. Now, if you ask me, no color at all in the background is the way to roll. That will leave us with a blank (albeit white) canvas for both the plot and panel.

ggplot(mtcars, aes(wt, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) +
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data") +
  theme(panel.background = element_blank(), 
        plot.background = element_blank())

Notice here that we have gone from specifying a color for the rectangle elements (element_rect()) to just making those elements blank. This lingo will become clearer the more time you spend with it, so if it is confusing now please just hang around a little longer. I like the grid lines as a default, so let’s bring them back in a casual grey but just for the major grids:

ggplot(mtcars, aes(wt, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) +
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data") +
  theme(panel.background = element_blank(), 
        plot.background = element_blank(),
        panel.grid.major = element_line(color = "#C4C4C4"))

Notice that we used panel.grid.major here. As you may suspect, panel.grid.minor would take care of those minor lines if we wanted them back. But, what may be less obvious, is that panel.grid would handle the major and minor grids together if you so wished. This goes for lots of things in the themes. For example, if we wanted to make our x-axis text as 12 point we would do this: theme(axis.text.x = element.text(size = 12)) but we could make all the axis text as 12-point by doing this: theme(axis.text = element.text(size = 12)). Again, this same pattern applies to many of the elements for which there are multiple iterations of the same thing.

But, ugh, now our grid lines conflict with our axis tick colors. We have two options, we could remove the ticks or change the colors (a lame third option would be to leave things as is). I prefer to just remove the ticks in this case:

ggplot(mtcars, aes(wt, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) +
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data") +
  theme(panel.background = element_blank(), 
        plot.background = element_blank(),
        panel.grid.major = element_line(color = "#C4C4C4"),
        axis.ticks = element_blank())

This gets us to a fairly nice looking plot. We will explore some additional theme() options below.

ggplot(mtcars, aes(wt * 1000, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) + 
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data") +
  theme_bw()

ggplot(mtcars, aes(wt * 1000, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) + 
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data") +
  theme_classic()

ggplot(mtcars, aes(wt * 1000, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) + 
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data") +
  theme_dark()

ggplot(mtcars, aes(wt * 1000, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) + 
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data") +
  theme_light()

ggplot(mtcars, aes(wt * 1000, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) + 
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data") +
  theme_linedraw()

ggplot(mtcars, aes(wt * 1000, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) + 
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data") +
  theme_minimal()

ggplot(mtcars, aes(wt * 1000, mpg, color = carb)) +
  geom_point() +
  geom_smooth(formula = y ~ x, method = lm) +
  scale_color_continuous(name = "Carburetors") +
  scale_x_continuous(labels = scales::comma) + 
  labs(x = "Car Weight in Pounds", y = "Miles per Gallon", 
       title = "The Relationship Between Car Weight and Miles Per Gallon",
       subtitle = "1974 Data") +
  theme_void()

Bar Plots

Let’s start with a basic bar chart.

ggplot(mtcars, aes(carb)) + 
  geom_bar() + 
  labs(x = "Number of Carburetors", y = "Count") +
  theme_cam()

What if we wanted to treat each level for the number of carburetors as discrete? We can just wrap it in factor() and the use fill = inside our aesthetic (aes()) function.

ggplot(mtcars, aes(factor(carb), fill = factor(carb))) + 
  geom_bar() + 
  labs(x = "Number of Carburetors", y = "Count") +
  theme_cam()

Ugh, who needs that ugly legend title? We will get to those in some other examples but for now let’s just kill the legend.

ggplot(mtcars, aes(factor(carb), fill = factor(carb))) + 
  geom_bar() + 
  labs(x = "Number of Carburetors", y = "Count") +
  theme_cam() +
  theme(legend.position = "none")

There is more than one way to remove the legend but this one is the clearest in my view. Notice that by putting theme(legend.position = "none") below theme_cam we overrode my preference for the legend in my custom theme function. Had we put it above the legend would still be there. Ordering matters in these things.

ggplot(mtcars, aes(cyl, hp, fill=factor(am))) +
  geom_bar(stat = "identity", position = position_dodge()) +
  labs(title="Grouped Bar Chart", 
       x = "Cylinders",
       y = "Horsepower") +
  scale_fill_discrete(guide = guide_legend(title = "Transmission", nrow = 1), 
                    labels=c("Automatic", "Manual")) + 
  scale_x_continuous(breaks = c(4,6,8)) +
theme_cam()

ggplot(mtcars, aes(cyl, hp, fill=factor(am))) +
  geom_bar(stat = "identity", position = position_dodge()) +
  labs(title="Grouped Bar Chart", 
       x = "Cylinders",
       y = "Horsepower") +
  scale_fill_manual(guide = guide_legend(title = "Transmission", nrow = 1), 
                    labels=c("Automatic", "Manual"),
                    values = c("#008000","#ff0000")) + 
  scale_x_continuous(breaks = c(4,6,8)) +
theme_cam()

mpg1 <- mpg 

capitalize <- function(string) {
  substr(string, 1, 1) <- toupper(substr(string, 1, 1))
  string
}

mpg1$manufacturer <- capitalize(mpg1$manufacturer) 

ggplot(mpg1, aes(manufacturer)) + 
  geom_bar(aes(fill = class), width = 0.5) + 
  labs(title="Stacked Bar Chart", 
       subtitle="Manufacturer of Vehicles", 
       x = "Manufacturer",
       y = "Count") +
  scale_fill_discrete(guide = guide_legend(title = "Class")) + 
  theme_cam() +
  theme(axis.text.x = element_text(angle=65, vjust=0.6)) +
  theme(legend.position = "right", legend.direction = "vertical")

Scatterplots

We already have a working scatterplot example, so I will start with something a little different and go from there.

Dot Charts

Line Charts

gganimate

## No renderer backend detected. gganimate will default to writing frames to separate files
## Consider installing:
## - the `gifski` package for gif output
## - the `av` package for video output
## and restarting the R session

## Warning: No renderer available. Please install the gifski, av, or magick package
## to create animated output

## NULL

ggthemes

ggforce

ggtimeseries

It also warrants mentioning that many packages include ggplot2 objects in their own flavor of making graphs. The syntax ends up being different in most cases to get started, but the output is a ggplot2 object that can then be manipulated. One of my favorites in this regard is the sjPlot package from @strengejacke which I use for plotting Likert scales (see my example below). Others include urbnmapr from the Urban Institute for making easy-peasy U.S. state maps (who wants to do that anyway?), choroplethr also for maps, and ggplotly for interactive graphics.

sjPlot

## List of 2
##  $ legend.spacing.x: 'simpleUnit' num 0.1cm
##   ..- attr(*, "unit")= int 1
##  $ panel.grid      : list()
##   ..- attr(*, "class")= chr [1:2] "element_blank" "element"
##  - attr(*, "class")= chr [1:2] "theme" "gg"
##  - attr(*, "complete")= logi FALSE
##  - attr(*, "validate")= logi TRUE