Chapter 5 Visualizing: ggplot2

Why do we start with data visualization? Not only is data viz a big part of analysis, it’s a way to SEE your progress as you learn to code.

“ggplot2 implements the grammar of graphics, a coherent system for describing and building graphs. With ggplot2, you can do more faster by learning one system and applying it in many places.” - R4DS

This lesson borrows heavily from Hadley Wickham’s R for Data Science book, and an EcoDataScience lesson on Data Visualization.

5.1 Objectives & Resources

5.1.1 Objectives

  • install our first package, ggplot2, by installing tidyverse
  • learn ggplot2 with a national parks visitation dataset (important to play with other data than your own, you’ll learn something.)
  • practice writing a script in RMarkdown
  • practice the rstudio-github workflow

5.2 Install our first package: tidyverse

Packages are bundles of functions, along with help pages and other goodies that make them easier for others to use, (ie. vignettes).

So far we’ve been using packages that are already included in base R. These can be considered out-of-the-box packages and include things such as sum and mean. You can also download and install packages created by the vast and growing R user community. The most traditional place to download packages is from CRAN, the Comprehensive R Archive Network. This is where you went to download R originally, and will go again to look for updates. You can also install packages directly from GitHub, which we’ll do tomorrow.

You don’t need to go to CRAN’s website to install packages, we can do it from within R with the command install.packages("package-name-in-quotes").

We are going to be using the package ggplot2, which is actually bundled into a huge package called tidyverse. We will install tidyverse now, and use a few functions from the packages within. Also, check out

When you do this, it will tell you which packages are inside of tidyverse that have also been installed. Note that there are a few name conflicts; it is alerting you that we’ll be using two functions from dplyr instead of the built-in stats package.

What’s the difference between install.packages() and library()? Why do you need both? Here’s an analogy:

  • install.packages() is setting up electricity for your house. Just need to do this once (let’s ignore monthly bills).
  • library() is turning on the lights. You only turn them on when you need them, otherwise it wouldn’t be efficient. And when you quit R, it turns the lights off, but the electricity lines are still there. So when you come back, you’ll have to turn them on again with library(), but you already have your electricity set up.

You can also install packages by going to the Packages tab in the bottom right pane. You can see the packages that you have installed (listed) and loaded (checkbox). You can also install packages using the install button, or check to see if any of your installed packages have updates available (update button). You can also click on the name of the package to see all the functions inside it — this is a super helpful feature that I use all the time.

5.4 Plotting with ggplot2

ggplot2 is a plotting package that makes it simple to create complex plots from data in a data frame. It provides a more programmatic interface for specifying what variables to plot, how they are displayed, and general visual properties. Therefore, we only need minimal changes if the underlying data change or if we decide to change from a bar plot to a scatterplot. This helps in creating publication quality plots with minimal amounts of adjustments and tweaking.

ggplot likes data in the ‘long’ format: i.e., a column for every dimension, and a row for every observation. Well structured data will save you lots of time when making figures with ggplot.

ggplot graphics are built step by step by adding new elements. Adding layers in this fashion allows for extensive flexibility and customization of plots.

5.5 Data

We are going to use a National Park visitation dataset (from the National Park Service at Read in the data using read_csv and take a look at the first few rows using head() or View().

## # A tibble: 6 x 7
##   region state code  park_name                     type          visitors  year
##   <chr>  <chr> <chr> <chr>                         <chr>            <dbl> <dbl>
## 1 PW     CA    CHIS  Channel Islands National Park National Park     1200  1963
## 2 PW     CA    CHIS  Channel Islands National Park National Park     1500  1964
## 3 PW     CA    CHIS  Channel Islands National Park National Park     1600  1965
## 4 PW     CA    CHIS  Channel Islands National Park National Park      300  1966
## 5 PW     CA    CHIS  Channel Islands National Park National Park    15700  1967
## 6 PW     CA    CHIS  Channel Islands National Park National Park    31000  1968

This dataframe is already in a long format where all rows are an observation and all columns are variables. Among the variables in ca are:

  1. region, US region where park is located.

  2. visitors, the annual visitation for each year

To build a ggplot, we need to:

  • use the ggplot() function and bind the plot to a specific data frame using the data argument
  • add geoms – graphical representation of the data in the plot (points, lines, bars). ggplot2 offers many different geoms; we will use some common ones today, including: * geom_point() for scatter plots, dot plots, etc. * geom_bar() for bar charts * geom_line() for trend lines, time-series, etc.

To add a geom to the plot use + operator. Because we have two continuous variables,
let’s use geom_point() first and then assign x and y aesthetics (aes):


  • Anything you put in the ggplot() function can be seen by any geom layers that you add (i.e., these are universal plot settings). This includes the x and y axis you set up in aes().
  • You can also specify aesthetics for a given geom independently of the aesthetics defined globally in the ggplot() function.
  • The + sign used to add layers must be placed at the end of each line containing a layer. If, instead, the + sign is added in the line before the other layer, ggplot2 will not add the new layer and will return an error message.

STOP: let’s Commit, Pull and Push to GitHub

5.6 Building your plots iteratively

Building plots with ggplot is typically an iterative process. We start by defining the dataset we’ll use, lay the axes, and choose a geom:

This isn’t necessarily a useful way to look at the data. We can distinguish each park by added the color argument to the aes:

5.7 Customizing plots

Take a look at the ggplot2 cheat sheet, and think of ways you could improve the plot.

Now, let’s capitalize the x and y axis labels and add a main title to the figure. I also like to remove that standard gray background using a different theme. Many themes come built into the ggplot2 package. My preference is theme_bw() but once you start typing theme_ a list of options will pop up. The last thing I’m going to do is remove the legend title.

5.8 ggplot2 themes

In addition to theme_bw(), which changes the plot background to white, ggplot2 comes with several other themes which can be useful to quickly change the look of your visualization.

The ggthemes package provides a wide variety of options (including an Excel 2003 theme). The ggplot2 extensions website provides a list of packages that extend the capabilities of ggplot2, including additional themes.

5.8 Exercise (10 min)

  1. Using the se dataset, make a scatterplot showing visitation to all national parks in the Southeast region with color identifying individual parks.
  2. Change the plot so that color indicates state.
  3. Customize by adding your own title and theme. You can also change the text sizes and angles. Try applying a 45 degree angle to the x-axis. Use your cheatsheet!
  4. In the code below, why isn’t the data showing up?
5.8 Answers (no peeking)

  1. The code is missing a geom to describe how the data should be plotted.

STOP: commit, pull and push to github

5.9 Faceting

ggplot has a special technique called faceting that allows the user to split one plot into multiple plots based on data in the dataset. We will use it to make a plot of park visitation by state:

We can now make the faceted plot by splitting further by park using park_name (within a single plot):

5.10 Geometric objects (geoms)

A geom is the geometrical object that a plot uses to represent data. People often describe plots by the type of geom that the plot uses. For example, bar charts use bar geoms, line charts use line geoms, boxplots use boxplot geoms, and so on. Scatterplots break the trend; they use the point geom. You can use different geoms to plot the same data. To change the geom in your plot, change the geom function that you add to ggplot(). Let’s look at a few ways of viewing the distribution of annual visitation (visitors) for each park (park_name).

None of these are great for visualizing data over time. We can use geom_line() in the same way we used geom_point.

ggplot2 provides over 30 geoms, and extension packages provide even more (see for a sampling). The best way to get a comprehensive overview is the ggplot2 cheatsheet. To learn more about any single geom, use help: ?geom_smooth.

To display multiple geoms in the same plot, add multiple geom functions to ggplot():

geom_smooth allows you to view a smoothed mean of data. Here we look at the smooth mean of visitation over time to Acadia National Park:

Notice that this plot contains three geoms in the same graph! Each geom is using the set of mappings in the first line. ggplot2 will treat these mappings as global mappings that apply to each geom in the graph.

If you place mappings in a geom function, ggplot2 will treat them as local mappings for the layer. It will use these mappings to extend or overwrite the global mappings for that layer only. This makes it possible to display different aesthetics in different layers.

5.10 Challenge

With all of this information in hand, please take another five minutes to either improve one of the plots generated in this exercise or create a beautiful graph of your own. Use the RStudio ggplot2 cheat sheet for inspiration.

Here are some ideas:

  • See if you can change the thickness of the lines or line type (e.g. dashed line).
  • Can you find a way to change the name of the legend? What about its labels?
  • Try using a different color palette (see

5.11 Bar charts

Next, let’s take a look at a bar chart. Bar charts seem simple, but they are interesting because they reveal something subtle about plots. Consider a basic bar chart, as drawn with geom_bar(). The following chart displays the total number of parks in each state within the Pacific West region.

On the x-axis, the chart displays state, a variable from visit_16. On the y-axis, it displays count, but count is not a variable in visit_16! Where does count come from? Many graphs, like scatterplots, plot the raw values of your dataset. Other graphs, like bar charts, calculate new values to plot:

  • bar charts, histograms, and frequency polygons bin your data and then plot bin counts, the number of points that fall in each bin.

  • smoothers fit a model to your data and then plot predictions from the model.

  • boxplots compute a robust summary of the distribution and then display a specially formatted box.

The algorithm used to calculate new values for a graph is called a stat, short for statistical transformation.

You can learn which stat a geom uses by inspecting the default value for the stat argument. For example, ?geom_bar shows that the default value for stat is “count”, which means that geom_bar() uses stat_count(). stat_count() is documented on the same page as geom_bar(), and if you scroll down you can find a section called “Computed variables”. That describes how it computes two new variables: count and prop.

ggplot2 provides over 20 stats for you to use. Each stat is a function, so you can get help in the usual way, e.g. ?stat_bin. To see a complete list of stats, try the ggplot2 cheatsheet.

5.11.1 Position adjustments

There’s one more piece of magic associated with bar charts. You can colour a bar chart using either the color aesthetic, or, more usefully, fill:

The stacking is performed automatically by the position adjustment specified by the position argument. If you don’t want a stacked bar chart, you can use "dodge".

  • position = "dodge" places overlapping objects directly beside one another. This makes it easier to compare individual values.

5.11.2 Challenge

With all of this information in hand, please take another five minutes to either improve one of the plots generated in this exercise or create a beautiful graph of your own. Use the RStudio ggplot2 cheat sheet for inspiration. Remember to use the help documentation (e.g. ?geom_bar)

Here are some ideas:

  • Flip the x and y axes.
  • Change the color palette used
  • Use scale_x_discrete to change the x-axis tick labels to the full state names (Arizona, Colorado, etc.)
  • Make a bar chart using the Massachussets dataset (mass) and find out how many parks of each type are in the state.

5.12 Arranging and exporting plots

After creating your plot, you can save it to a file in your favorite format. The Export tab in the Plot pane in RStudio will save your plots at low resolution, which will not be accepted by many journals and will not scale well for posters.

Instead, use the ggsave() function, which allows you easily change the dimension and resolution of your plot by adjusting the appropriate arguments (width, height and dpi):

Note: The parameters width and height also determine the font size in the saved plot.

5.13 Bonus

So as you can see, ggplot2 is a fantastic package for visualizing data. But there are some additional packages that let you make plots interactive. plotly, gganimate.

## Error in library(plotly): there is no package called 'plotly'
## Error in ggplotly(my_plot): could not find function "ggplotly"
## Error in ggplotly(acad_vis): could not find function "ggplotly"

5.14 Save and push to GitHub