Annual average temperatures of the United States: The first data file, usa_temp.csv, contains the annual average temperatures of the USA from 1971 to 2001. The data was made available by the National Climatic Data Center of the United States, National Oceanic and Atmospheric Administration, and has been compiled by current results.

Reading in map and temperature data: First, we use the read.csv() function, known from the Reading data from different file formats recipe, to read our data and assign it to the variable usa_temp. Next, we use the map_data() function from the ggplot2 package to read in the United States map from maps as a data frame.

Note that in contrast to the heat map functions that we have been using in the previous recipes, the gplot() function takes a data frame as input instead of data in a numerical matrix format. And as we remember from the Reading data from different file formats recipe, data that we read via read.csv() is converted into a data frame automatically.

Merging and sorting the data frames: Now we will merge the map and temperature data:

usa_data <- merge(usa_temp, usa_map, 
by.x = "state", by.y = "region") 
usa_sorted <- usa_data[order(usa_data["order"]),]

The following flowchart illustrates this process and shows how the data looks like before and after the merging and conversion:

As we can see in the preceding chart, the map data in the usa_map data frame contains multiple longitudinal (long) and latitudinal (lat) coordinates for each state in the column labeled with region. The numbers in the order column specify the order in which the single dots are connected when we draw the map as a polygon.

After we merged both map data and temperature data, we can see that the values in the order column have been shuffled. This would result in quite a mess when we wanted to construct the choropleth map from this data frame. Therefore, we use the order() function to restore the original order before we merged the data sets.

Constructing our first choropleth map: Now that we have our data ready in a nice format, we can proceed to the main plotting functions to create our first choropleth map:

usa_map1 <- ggplot(data = usa_sorted) + 
  geom_polygon(aes(x = long, y = lat, group = group, 
fill = fahrenheit)) + 
  ggtitle("USA Map 1")

Basically, how the ggplot2 package works is that we have to create our plots incrementally. First, we use the ggplot() function to assign our data to a new plot object, and then we can add further layers to it. The basic shape of ggplot2 plots is determined by so-called geoms, or geometric objects. Here, we are using geom_polygon(), which will connect our coordinate points to a map. The aes() function nested inside is there for aesthetics and defines the visual properties of the geoms. We provide the variable fahrenheit as an argument for the fill parameter so that we can shade the areas of our choropleth maps according to the Fahrenheit temperatures in our data set.

Customizing choropleth maps: One of the advantages of ggplot2 is that we do not have to retype the whole heat map function with its arguments each time we want to modify the map, since we store our plots as objects. So if we want to convert our map into a polyconic projection, we can simple reuse our old graphic object and make a small modification:

 usa_map2 <- usa_map1 + coord_map("polyconic") + 
  ggtitle("USA Map 2 - polyconic")

Now, let us add another geometric object so that the state borders will be drawn as black lines:

usa_map3 <- usa_map2 + 
  geom_path(aes(x = long, y = lat, group = group), 
color = "black") + 
  ggtitle("USA Map 3 - black contours")

Since we are showing temperatures on our United States map, it would be more appropriate to replace the blue default color gradient by a color gradient from yellow to red. We can modify the color gradient by adding the scale_fill_gradient() function with two color arguments for our previous graphic object:

usa_map4 <- usa_map3 + 
  scale_fill_gradient(low = "yellow", high = "red") + 
  ggtitle("USA Map 4 - gradient 1")

If we want to add a third color to our gradient, we can use the scale_fill_gradient2() function instead. For this function, we need an additional argument that specifies the position (mid-point) of the second color. We can simply use the temperature mean such as a midpoint measure:

usa_map5 <- usa_map3 + 
scale_fill_gradient2(low = "steelblue", mid = "yellow",
high = "red",  midpoint =   
colMeans(usa_sorted["fahrenheit"])) + 
  ggtitle("USA Map 5 - gradient 2")

Extracting regions from the world map: Now that we have seen how we can use ggplot2 to create simple choropleth maps, let us explore some advanced features.

As you can see in the table at the end of this section, the number of maps in the maps and mapdata packages is quite limited. However, we are able to extract individual countries from the world map.

Our second data set, south_am_pop.csv, contains recent population counts of all the countries of South America. Unfortunately, neither maps nor mapdata contains a map of this continent, so we extract all the South American countries from the high resolution world map of mapdata.

south_am_map <- map_data("worldHires", region = c("Argentina",
"Bolivia", "Brazil","Chile", "Colombia", "Ecuador", 
"Falkland Islands", "French Guiana", "Guyana", 
"Paraguay", "Peru", "Suriname", "Uruguay", "Venezuela"))

After we read the data from south_am_pop.csv and merge and sort the data frames, we can create the choropleth map:

south_am_map1 <- ggplot(data = south_am_sorted) + 
  geom_polygon(aes(x = long, y = lat, 
group = group, fill = population)) +
  geom_path(aes(x = long, y = lat, group = group), 
color = "black") + 
  coord_map("polyconic") + 
scale_fill_gradient(low = "lightyellow",
  high = "red", guide = "legend")

As we have seen it for the USA map before, we use the ggplot() function to create a new plot object and geom_polygon to construct the map graphic. With the color parameter in geom_path, we add a black border around the individual countries, and with the coord_map function, we convert our map into a polyconic projection. We also change the color gradient from light-yellow to red and make the legend categorical by providing the argument legend for the guide parameter.

By default, ggplot2 creates plots on a gray background with a white grid. To get a nicer layout, let us create a map on a clean, white background and remove axes tick marks, labels, and titles altogether:

south_am_map2 = south_am_map1 + 
  theme(panel.background = element_blank(),
  axis.text = element_blank(), 
  axis.title = element_blank(), 
  axis.ticks = element_blank())

In the following image, you can see the resulting choropleth map of South America's population count on a white background:

Volcano contour plot: As mentioned in the introduction of this recipe, we want to take a look at another type of map representation, contour plots:

data(volcano)
image.plot(volcano)

Using the image.plot() function from the fields library, we construct a color grid with the topographical data of a volcano from R's data package. We could also use the image() base function in R, but the image.plot() function has some nice additional features, such as placing a legend for the color grid to the right of the plot.

After we created the underlying color grid, we use the contour() function to place the contour lines on top of the color grid.

contour(volcano, add = TRUE)

The following image shows the final contour plot that we have created from the volcano data set: