How to make heatmaps in ggplot

Heatmaps are a common way of representing data. In this blog post, I'll show you how to make your own heatmaps using ggplot. In the process, you'll learn a bit about working with the {sf} package, specifically the st_make_grid() function to make a grid, the st_intersection() function to clip the boundaries of your geography to the grid you create, and st_join() to do spatial joins.

This blog post is adapted from a lesson in the Mapping with R course. If you want to learn to make heatmaps (and much, much more!), check it out.

What is a heatmap?

Before learning to make a heatmap, let's talk about what a heatmap is. Heatmaps may be common, but a single definition of a heatmap is less so. Search for tutorials on making heatmaps in ggplot and you'll get tutorials for using the geom_tile() function to make heatmaps like this:

In this blog post, however, I want to talk about heatmaps that are actually maps. There are a number of types of heatmaps maps (is that a phrase?) you'll see in the wild. This map from the Washington Post, for example, shows total precipitation on the Korean peninsula during a particularly rainy period in 2022.

Or this map by Tobias Stadler showing the locations of Swiss villages with populations over 10,000.

What all heatmaps do is take some phenomena and bucket outcomes into some type of grid:

• For the measles cases chart, that involves creating one square for each year and state.

• For the Korean precipitation map, this means taking readings from rain monitoring stations and grouping them to create the smoothed colors you see on the map.

• For Tobias Stadler's Swiss villages map, this means creating a grid of Switzerland, putting villages within one of the grid cells, and then counting the number of villages within each cell.

After creating grids, all three of these visualizations then use color to show the density of some outcome (measles cases, precipitation, number of 10k+ population villages). With this in mind, let's dive into making our own heatmap.

Start our heatmap

We're going to make a heatmap showing the location of improved corners in Portland, Oregon (where I live). These are corners that have a ramp which makes them accessible for folks in wheelchairs, people pushing strollers, etc. I took this photo recently of a corner being fixed up and an already-improved corner in the background for comparison.

Import data

To start our map, we’ll load several packages: the {tidvyerse} for general data wrangling and mapping with ggplot, {sf} for working with geospatial data, and {scales} to make nicely formatted values.

Next, we’ll import our data. We begin by importing a geojson file with the location of all corners in Portland.

We can look the improved_corners data frame we’ve created and see that it consists of an id variable ( objectid) , a ramp_style variable (which is either Improved or Unimproved), and a geometry column, which consists of the location of each corner:

We’ll also import a geojson file that has the boundaries of the city of Portland.

The easiest way to see what this data looks like is with a quick map, which we can do with ggplot:

This code gives us this map:

Create a grid map

Next, we’re going to take our portland_boundaries object and create a grid from it. The st_make_grid() function enables us to do this as follows:

We can see what this grid looks like by plotting it:

This code gives us a grid map overlaid on top of the boundaries of Portland.

By default, the st_make_grid() creates a 10 by 10 grid. However, to make our heatmap, we’d like to have more cells. So let’s adjust our code to make a 100 by 100 grid:

The same code as before makes a map that reflects the more fine-grained cells:

Clip city boundaries to the grid map

We’ve made a grid, but the grid has many cells outside of the boundaries of Portland. To clip the grid to these boundaries, we can use the st_intersection() function as follows. After st_intersection() , we also run st_make_valid() , which deals with an issue particular to the city of Portland where there is separate city within its . I also create a grid_id variable, which we will use below when joining the data on corners with our grid map.

We can now plot the portland_grid_map object:

Which gives us this map:

Join our corners data with the grid map

Now that we’ve created a grid map that is clipped to the boundaries of Portland, we need to join our data on corners with it. Doing so will enable us to see where there are higher concentrations of unimproved corners. We join our portland_grid_map and improved_corners objects using the st_join() function:

If we look at improved_corners_grid , we can see that it has each corner joined to the grid cell within which it is located.

From there, we need to calculate the percentage of unimproved corners in each grid. We can do this with some basic data wrangling using various {dplyr} functions (see around 7:00 of the video for a full walkthrough of this code). The code below also sees us use st_drop_geometry() to turn geospatial data into a regular data frame before we later turn it back into geospatial data with the st_as_sf() function (we do this in order to speed up our code, which tends to run slowly on geospatial data).

Let’s now look at our unimproved_corners_grid_pct object. As you can see, we now have one row for each grid cell, with a pct variable that shows the percentage of unimproved corners in that cell.

Make the heatmap with ggplot

Having created a grid, clipped it to Portland boundaries, joined in our data on improved corners, and calculated the percentage of unimproved corners in each grid cell, we are now ready to create our heatmap. The code below creates the heatmap. For a full walkthrough of the design decisions, check out the video starting at around 10:00.

The result of this code is a great-looking heatmap that higlights areas of Portland with more unimproved corners.

Summing up

As you’ve seen the process of making a heatmap in ggplot is a bit involved so let’s summarize:

1. Import data on improved corners and data on the boundaries of Portland

2. Create a grid map based on the boundaries data

3. Join data on improved corners with the grid map

4. Calculate the percentage of unimproved corners in each grid cell

5. Map the resulting data, with cells with higher percentages of unimproved corners in different colors

Import data on improved corners and data on the boundaries of Portland

Map the resulting data, with cells with higher percentages of unimproved corners in different colors

While I’ve given an example on making a heatmap of unimproved corners in Portland, you can use this process to make heatmaps for any outcome in any location. Good luck making your own heatmaps!