Introduction to Graphics and Temperature Change

1.1 Factors and Forcats

To impose a different ordering schema on month_name, we’ll need to turn it into a factor - a character vector that has a set of ordered levels. If we had used read.csv() to load the data, this would have already been done - but is generally bad practice to assume.

To create a factor, we can use factor(). We can see the order of the levels with levels().

hadcrut_temp_anomoly$month_name <- factor(hadcrut_temp_anomoly$month_name)

levels(hadcrut_temp_anomoly$month_name)

##  [1] "Apr" "Aug" "Dec" "Feb" "Jan" "Jul" "Jun" "Mar" "May" "Nov" "Oct"
## [12] "Sep"

Uh oh - alphabetical! Enter forcats - a wonderful library from the tidyverse designed to work with factors in just such a scenario. There are a number of useful functions such as fct_recode() for changing the names of different factor levels, fct_relevel() for specifying arbitrary factor level orders, fct_rev() for reversing level order, and more. We’re going to use fct_inorder which specifies level order in the order we see the first appearance of each level. As the data is sorted by month, this should work out just like we need.

library(forcats)

hadcrut_temp_anomoly$month_name <- fct_inorder(hadcrut_temp_anomoly$month_name)

levels(hadcrut_temp_anomoly$month_name)

##  [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov"
## [12] "Dec"

Notice now that month_name’s class changes when we look at hadcrut_temp_anomoly

hadcrut_temp_anomoly

## # A tibble: 1,992 x 4
##     year month anomaly month_name
##    <int> <int>   <dbl> <fct>     
##  1  1850     1  -0.702 Jan       
##  2  1851     1  -0.303 Jan       
##  3  1852     1  -0.308 Jan       
##  4  1853     1  -0.177 Jan       
##  5  1854     1  -0.36  Jan       
##  6  1855     1  -0.176 Jan       
##  7  1856     1  -0.119 Jan       
##  8  1857     1  -0.512 Jan       
##  9  1858     1  -0.532 Jan       
## 10  1859     1  -0.307 Jan       
## # ... with 1,982 more rows

Exercise: Make a new column that contains the same information as month_name. Now, try fct_rev(), fct_relevel(), and last, fct_recode() on it to futz with the factor levels. After each one, look at the output of levels() to see what you did.

2.1 Visualizing distributions

All right! Let’s try out ggplot2. ggplot2 works simply by you specifying things in roughly the following order:
1. A ggplot2 object which links to a data set and has information about aesthetics.
2. A geom or geometry which specifies how the data is to be seen.
3. Other bells and whistles which we will get to.

We add these pieces together with a + sign. So let’s start with something simple, just visualizing a distribution. First, we have to create a ggplot. We’ll link it to the hadcrut_temp_anomoly data, and map x to anomaly using the aes function, as we’re going to look at the distribution of anomaly.

library(ggplot2)

had_dens <- ggplot(data = hadcrut_temp_anomoly,
       mapping = aes(x = anomaly))

had_dens

Wait, what? Nothing happened! That actually makes sense, as we haven’t told ggplot2 anything about plotting! There’s no geom. For starters, let’s try the simple geom_histogram()

had_dens +
  geom_histogram()

## `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.

Nice! Aside from R yelling at us and giving telling us to use a different bin size, it’s not bad!

Exercise: Now you try geom_density. How’s it look? If you want, try adding arguments like fill, color, and alpha to geom_density() if you want to get fancy.

2.2 Visualizing multiple distributions

To view multiple distributions, we’ll need aesthetics that specify groupings. We’ll look in a minute at how we put those on an axis themselves, but for now, let’s introduce group.

had_dens_group <- ggplot(data = hadcrut_temp_anomoly,
       mapping = aes(x = anomaly, group=month_name))

There’s a lot we can try here. Let’s revisit one old friend.

had_dens_group + 
  geom_density()

Well that shows something interesting, doesn’t it! What if we don’t overlap? We can try a few different ‘position’ arguments.

had_dens_group + 
  geom_density(position="stack")

had_dens_group + 
  geom_density(position=position_dodge(width=3))

## Warning: position_dodge requires non-overlapping x intervals

Exercise: Now you try geom_histogram. How’s it look? Bad, right? Try different colors, alphas, and fills to see if you can improve. Maybe a different position?

3.1 Starting a plot

ggplot2 contains a number of different types of geometries for displaying information in two dimensions However, all of them begin by giving ggplot2 some information, just as before. What data is going to be used? What elements of that data will map onto different aesthetic values and scales in the plot? We’ll start by creating the base of our plot with the x-axis being month and the y-axis being temperature anomoly.

had_plot_base <- ggplot(data = hadcrut_temp_anomoly,
                        mapping = aes(x = month_name, y = anomaly))

Great! We have the basics of our plot saved as an object.

3.2 Scatterplots

To take a basic plot and add a geometry choice to it, we use one of the family of geom_s in ggplot2. One of the most basic plot types we ever encounter is the scatterplot. y versus x. That’s all. For that, we have geom_point()

had_plot_base +
  geom_point()

This is great! But, well, a few things. First, man, lots of points overlap. If only they were kinda transparent. Second, maybe they’re too small? Each geom has a number of options for different visual elements - color, size, alpha, etc. So, for example, we can modify this plot a bit.

had_plot_base +
  geom_point(alpha = 0.5, size=3)

Note - all of these are relative to 1. Well, now we can see the distribution of points a bit better, given overlap. But….

3.3 Jitter

Maybe we want to add a bit of random noise to the points, to better visualize what’s going on here. For that, there’s geom_jitter.

had_plot_base +
  geom_jitter()

Neat! You can see the density of each cluster for each month so much more clearly! Now, you may be wondering - hold on - I only want to add jitter to the x-axis, not the y-axis. For that, there’s the width and height argument of how much jitter room there is to spare. So - let’s say we want the points to vary in the x by \(\pm\) 0.5, but 0 in the y. And let’s throw in some alpha for good measure.

had_plot_base +
  geom_jitter(width=0.5, height=0, alpha=0.8)

2.4 Exercise: Boxplot, Violins, and stacking.

This is all well and good, but, eyeballing is not the same as some solid information on the distribution of the data. Let’s try some of the 2D ways of visualizing data.

1. Try out the following geoms - geom_boxplot(), geom_violin(), stat_summary(). Which do you prefer?
   
2. Try adding multiple geoms together. Does order matter?
   
3. If you want to get saucy, install ggridges. You’ll have to swap x and y in your mapping, but, try out geom_density_ridges()

3.5 Lines

OK - but these are timeseries! We need lines, no? There is, of course, a geom_line that shows lines connecting points, but does not show the points (yes, you can layer both geom_line and geom_point).

had_plot_base +
  geom_line()

UGH - what happened? Welp, because month_name is a factor, all of the points within a month were connected. Oops! There is a way around it, and that is to specify what your groups are, rather than let ggplot define it for you.

One of the nice things about geoms is that we can add aesthetic elements from the data frame. Heck, if you want, you can add a geom with a whole new data set and new aesthetics, but for now, let’s just redefine the group aesthetic.

had_plot_base +
  geom_line(mapping = aes(group=year))

Perfect! We are on our way!

Exericise: Try a line plot, using group = month. Feel free to play with other elements of the plot, such as alpha.

4.1 Color

As color is the most common modification, let’s concentrate on that. The lessons can be used broadly for other scales.

had_lines <- had_plot_base +
  geom_line(mapping = aes(group=year, color=year))

had_lines

A few things to note. First, year is treated continuously, so it’s placed on a gradient. Second the default color gradient is from dark to light blue.

This is great, but what if we want different colors? If your colors are continuous, the first go-to to change them is scale_color_continuous - and we add scales just like we added geoms before. Let’s start with a traditional blue to red gradient.

had_lines +
  scale_color_continuous(low = "blue", high = "red")

This works great. We could also have used scale_color_gradient exactly the same way to achieve the same results. If you want to know more of what colors are available in R, see this post or

4.2 More on Gradients

This is much better. But it’s still hard to see the middle ranges of years For that, we have the scale_gradient_2 function, which takes an argument for what the midpoint color should be, but then you have to specify the value for that midpoint. Let’s just go with the 1925.

had_lines +
  scale_color_gradient2(low = "blue", mid = "yellow", high = "red",
                        midpoint = 1925)

Groovy! What if we wanted something more arbitrary - say, a 7 colors of the rainbow gradient? scale_color_gradientn has you covered.

had_lines +
  scale_color_gradientn(colors=rainbow(7))

Note the rainbow() function. R comes with a few different color palatte functions (and see the colors helpfile for how to view all of the colors in R). For each palatte, we feed it a number of colors, and get a vector back. Using some code from the rainbow helpfile, here ar ethe default pallates.

Try one, and see what it does to you!

4.3 More Organized Gradients

There are of course a ton of packages with other pallates our there. One of the most popular, because it’s color selection is based on research looking at color blindness, and how we see sequential or diverging palattes of color, is RColorBrewer. You can view a lot more about it at http://colorbrewer2.org/ - for now, let’s take a gander at what it provides.

#install.packages("RColorBrewer")
library(RColorBrewer)

display.brewer.all(n=10, exact.n=FALSE)

That’s a lot. Which of these do you think is best for seeing differences between years? Why? I admit, I’m often partial to BrBG

had_lines +
  scale_color_gradientn(colors=brewer.pal(n = 7, 
                                          name = "BrBG"))

4.4 More Color Packages

In point of fact, there are many different color palette packages out there. I’ll just leave you with two more. The first is my personal favorite - the Wes Anderson package - https://github.com/karthik/wesanderson. Don’t worry, there are install packages on the github page.

The second is the viridis palatte. This is a pretty common yellow–blue-based palette (and the package - https://cran.r-project.org/web/packages/viridis/vignettes/intro-to-viridis.html - also comes with a ‘magma’ palette as well.) These two palettes are great as they show up well for people with color blindness. Heck - if you really want to have color-blind safe color schemes, you might also want to check out the dichromat package - it not only contains multiple colorblind safe palettes, but it also allows you to see what your color palette will look like under different forms of color blindness.

So, it’s no accident that viridis is what was used for the original animation. Let’s make it our own. We’ll also add guide = 'none' to lose the colorbar at ths side.

library(viridis)

## Loading required package: viridisLite

had_lines +
  scale_color_viridis(guide="none")

4.5 Exercises

1. What happens to our histogram if we add a fill argument. Try fill = month and fill = factor(year) (note that without the factor, nothing happens!). You might also want to remove the guide with + guides(fill = "none").

2. Create a line plot of year on the x and anomoly on the y. Include month as a group. Try coloring by anomoly as well. First use the default palatte, and then try a blue-white-red.

3. Now color that line plot by month. Try at least two different palettes either of your own devising or from an additional package. Note, if you use month_name, you’ll be mucking about with scale_color_manual. Or you can use RColorBrewer which handles discrete groups easily using scale_color_brewer().

5.2 Faceting by continuous values

It’s a little bit more difficult to facet our monthly plot. Maybe we want to split it up by decade. But, wait, year is continuous. What to do? R and ggplot2 have a number of functions based off of the base function cut(). Let’s try the first, that can make decadal plots.

had_lines +
  facet_wrap(~cut_width(year, 10))

It’s not pretty (that’s a lot of decades!), but you can see the principle.

Exercise: 1. Try out cut_interval and cut_number. What do they do?
2. Make a plot where facets and colors reflect the same information.

8.1 Adding lines

First, there are two critical lines - 1.5 and 2.0 degrees C. To add a vertical or horizontal line to the plot, we use geom_vline or geom_hline. These accept a xintercept or yintercept, respectively, to indicate where they should cross a plot. So, to add to our current plot.

had_lines_annotated <- had_lines_color_theme +
  geom_hline(yintercept=c(1.5, 2.0), color="red")

had_lines_annotated

8.3 Title

And last, titles are easy. There’s a function for it! ggtitle

had_lines_annotated <- had_lines_annotated +
  ggtitle("Global Temperature Change (1850-2015)")

had_lines_annotated

9.1 Axis limits

First, we want to have the lines extend all the way to the edges of the graph. So, to do that, we want the limits of the x-axis to be set to Jan and Dec. The xlim() function (and there is a ylim() function as well) should take care of that. If we had a continuous scale, we’d just feed a vector, with minimum and maximum - e.g. c(1,12).

But, here we want to feed the factor vector from which everything is derived. We’ve taken care of ordering, so, we no longer need xlim(). Instead, we want to use the scale_x_discrete function that lets us set properties of an x axis with discrete values. In our case, we want to alter how much additional space is placed around the first and last month using the expand argument. So let’s cut that down to 0!

had_lines_annotated_final <- had_lines_annotated + 
  coord_cartesian(expand=FALSE)
  
had_lines_annotated_final

The labels get cut off - but they’ll come back in a second!

9.2 Axis modification

There are a number of ways to modify an axis. Using scale_x_continuous() provides access to a rich number of ways to modify the x axis (or replace with y, and you get the picture).

Often we’re interested in log transforming our axes:

had_lines_annotated_final + 
  scale_y_log10()

Here, this isn’t a great idea, as we lose the negative numbers. But, you can begin to see the power of how the different axis scales can work. We can invoke an arbitrary scale using the trans argument of scale_x_continuous(), although there are many already buit in.

We want a circular plot, however, which implies polar coordinates. And there’s an option for that, too! We’ll also have to deal with that expansion issue again.

had_lines_annotated_final <- had_lines_annotated_final +
  coord_polar()+ 
  scale_x_discrete(expand=c(0,0))

## Coordinate system already present. Adding new coordinate system, which will replace the existing one.

had_lines_annotated_final

Oh! Fancy! Almost there!

9.3 Axis labeling

The whole month name, anomaly think on the axes is a little odd. Fortunately, we can replace the string labels on either axis. We could have put in other things, but for now, let’s go blank.

had_lines_annotated_final <- had_lines_annotated_final +
  xlab("") +
  ylab("")

had_lines_annotated_final

For more great ggplot2 extensions, see https://www.ggplot2-exts.org/