Creating Interactive Maps with R: A Beginner’s Guide Using ggplot2 and leaflet

R
R Tutorial
Maps
ggplot
leaflet
tidyverse
environmental monitoring
Author

Kishore Kumar Jagadeesan

Published

July 11, 2024

TL;DR

In this tutorial, you’ll learn how to create static maps using ggplot2 and interactive maps using leaflet in R. We’ll cover the basics, provide code examples, and include tips and troubleshooting advice. By the end, you’ll be able to create customized maps to visualize geographic data effectively.

Welcome to this step-by-step tutorial where you’ll learn how to create beautiful and interactive maps using R. We’ll be using two powerful R packages: ggplot2 for static maps and leaflet for interactive maps. Whether you’re a beginner or looking to refine your mapping skills, this guide will walk you through the basics and provide some handy tips and tricks along the way.

1 Introduction

Mapping is a crucial part of data visualization, helping to present geographic data in an easily understandable way. In this tutorial, we will:

  1. Create a static map using ggplot2.
  2. Create an interactive map using leaflet.

By the end of this guide, you will have a good understanding of how to create and customize maps in R.

When to Use Which
  • ggplot2: Ideal for static visualizations and publication-quality maps.
  • leaflet: Perfect for interactive and dynamic maps that engage users.

2 Prerequisites

Ensure you have R and RStudio installed on your computer. You will also need to install the necessary packages.

install.packages(c("ggplot2", "magrittr",  "sf", "leaflet", "rnaturalearth", "rnaturalearthdata", "ggspatial", "ggrepel", "htmlwidgets"))

3 Creating a Static Map with ggplot2

3.1 Step 1: Load the Libraries

First, load the required libraries.

Code 
library(ggplot2)
library(magrittr)
library(rnaturalearth)
library(rnaturalearthdata)
library(sf)
1
Load the ggplot2 package for data visualization.
2
Load the magrittr package for pipe operations.
3
Load the rnaturalearth package to access natural earth map data.
4
Load the rnaturalearthdata package for additional natural earth data.
5
Load the sf package for handling spatial data.

3.2 Step 2: Load the Data

For this tutorial, we’ll use the rnaturalearth package, which provides natural earth vector map data in various scales. We’ll load world map data using this package.

Code 
world_map <- rnaturalearth::ne_countries(scale = "medium", returnclass = "sf")
1
Loads the world map data at a medium scale and returns it as an sf (simple features) object.

3.3 Step 3: Create the Map

We’ll use ggplot2 to plot the world map.

Code 
ggplot_map <- ggplot2::ggplot(world_map) +
  ggplot2::geom_sf() +
  ggplot2::theme_minimal() +
  ggplot2::labs(title = "World Map", x = "Longitude", y = "Latitude") +
  ggplot2::theme(
    panel.grid.major = element_line(color = gray(.5), 
                                    linetype = "dashed", size = 0.5),
    panel.background = element_rect(fill = "aliceblue"))
ggplot_map
1
Create a ggplot object using world_map data.
2
Plot the geographic features using geom_sf.
3
Apply a minimal theme to the plot.
4
Add title and axis labels.
5
Customize the major grid lines.
6
Set the background colour to aliceblue.
7
Display the map.

3.4 Step 4: Save the Map

Once the final map is prepared, it can be conveniently saved in various formats using the ggsave() function. The formats include the widely used PNG (a raster bitmap) and PDF (vector graphics), with the ability to control the size and resolution of the output. In this case, we are saving a PDF version of the map, which maintains the highest quality, and a PNG version for web usage

ggplot2::ggsave("ggplot_map.png", 
       plot= ggplot_map, 
       width = 6, height = 8, dpi = "screen")
ggplot2::ggsave("ggplot_map.pdf", 
       plot= ggplot_map, 
       width = 6, height = 8, dpi = 300)
1
Save map as a PNG file with screen resolution.
2
Save map as a PDF file with 300 dpi resolution
ggsave()

If you’re creating a PDF for web use, a dpi of 72 is usually sufficient. If you’re creating a PDF for print, a dpi of 300 or higher is recommended. If you’re not sure what dpi to use, it’s best to check with your printer or the specifications of the website where you plan to upload the PDF.

3.5 Customizing the Static Map

3.5.1 Adding additional layers: An Example with Points

To make your static map more informative and visually appealing, you can add additional layers such as points representing specific locations. Here’s how to do it step-by-step.

3.5.1.1 Step 1: Create a Data Frame with Location Data

First, create a data frame containing the locations you want to plot on the map.

Code 
sites <- data.frame(
  city = c("Bath","Keynsham", "Bristol", "Chippenham", "Trowbridge"),
  latitude = c(51.380001, 51.41505900, 51.45451300, 51.45805800, 51.31966400),
  longitude = c(-2.360000, -2.50252600, -2.58791000, -2.11607390, -2.20885300))
head(sites)
1
Create a data frame named sites.
2
Define the city column with city names.
3
Define the latitude column with the corresponding latitudes.
4
Define the longitude column with the corresponding longitudes.
5
Display the sites data frame. 
        city latitude longitude
1       Bath 51.38000 -2.360000
2   Keynsham 51.41506 -2.502526
3    Bristol 51.45451 -2.587910
4 Chippenham 51.45806 -2.116074
5 Trowbridge 51.31966 -2.208853

3.5.1.2 Step 2: Plot the Map with Additional Layers

Next, use ggplot2 to create a map with the world map data and add points from the sites data frame.

Code 
ggplot_map <- ggplot2::ggplot(world_map) +
  ggplot2::geom_sf() +
  ggplot2::geom_point(data = sites, ggplot2::aes(x = longitude, y = latitude), size = 2, shape = 23, fill = "darkred") +
  ggplot2::theme_minimal() +
  ggplot2::labs(title = "My Map", x = "Longitude", y = "Latitude") +
  ggplot2::coord_sf(xlim = c(-3.6, -1.5), ylim = c(50.5, 52), expand = FALSE) +
  ggplot2::theme(
    panel.grid.major = element_line(color = gray(.5), 
                                    linetype = "dashed", size = 0.5),
    panel.background = element_rect(fill = "aliceblue"))
ggplot_map
1
Create a ggplot object using world_map data.
2
Plot the geographic features using geom_sf.
3
Add points from sites data with longitude and latitude, customized size, shape, and fill colour.
4
Apply a minimal theme to the plot.
5
Add title and axis labels.
6
Set the spatial coordinates to focus.
7
Customize the major grid lines.
8
Set the background colour to aliceblue.
9
Display the map.

By following these steps, you can add various layers to your static maps, enhancing the visualization with additional data points and custom styling.

4 Creating an Interactive Map with Leaflet

4.1 Step 1: Load the Libraries

Load the leaflet library

Code 
library(leaflet)
1
Load the leaflet package for interactive maps.

4.2 Step 2: Create the Map

We’ll create an interactive map centered on a specific location.

Code 
leaflet_map <- leaflet::leaflet() %>%
  leaflet::addTiles() %>%
  leaflet::addMarkers(lng = -0.09, lat = 51.505, popup = "Hello, London!")
leaflet_map
1
Initialize a leaflet map object.
2
Add default OpenStreetMap tiles to the map.
3
Add a marker at the specified longitude and latitude with a popup message.
4
Display the map.
Explore Different Basemaps

Change the basemap using addProviderTiles() function, e.g., addProviderTiles(providers$Stamen.Toner)

4.3 Step 3: Customize the Map

Let’s add more features, such as multiple markers and custom popups.

Code 
leaflet_map <- leaflet::leaflet() %>%
  leaflet::addTiles() %>%
  leaflet::addMarkers(lng = c(-0.09, -0.1), lat = c(51.505, 51.51),
             popup = c("Hello, London!", "Another Location"))
leaflet_map
1
Initialize a leaflet map object.
2
Add default OpenStreetMap tiles to the map.
3
Add multiple markers at specified longitudes and latitudes.
4
Add custom popup messages for each marker.
5
Display the map.

5 Additional Customizations

5.1 Advanced ggplot2 Features

To enhance your static maps further, you can customize themes, add annotations, and use scale transformations. These advanced features can make your map more informative and visually appealing.

Code 
library(ggspatial)
library(ggrepel)

ggplot_map <- ggplot2::ggplot(world_map) +
  ggplot2::geom_sf() +
  ggplot2::geom_point(data = sites, ggplot2::aes(x = longitude, y = latitude), size = 2, shape = 23, fill = "darkred") +
  ggrepel::geom_text_repel (data =  sites,
            ggplot2::aes(x = longitude, y = latitude,
                         label= city), 
            size = 4 ) +
  ggplot2::theme_minimal() +
  ggplot2::labs(title = "My Map", x = "Longitude", y = "Latitude") +
  ggplot2::coord_sf(xlim = c(-3.6, -1.5), ylim = c(50.5, 52), expand = FALSE) +
  ggplot2::theme(
    panel.grid.major = element_line(color = gray(.5), 
                                    linetype = "dashed", size = 0.5),
    panel.background = element_rect(fill = "aliceblue")) +
  ggspatial::annotation_north_arrow(
     location = "tl",
     pad_x = unit(0.1, "in"),
     pad_y = unit(0.1, "in"),
     style = ggspatial::north_arrow_fancy_orienteering(
       line_col = "black",
       text_size = 12,
       text_col = "black")) +
  ggspatial::annotation_scale(
    location = "br",
    width_hint = 0.3,
    text_cex = 0.5,
    pad_x = unit(0.1, "cm"),
    pad_y = unit(0.1, "cm"))
ggplot_map
1
Load the ggspatial package for spatial annotations.
2
Load the ggrepel package for repelling text labels.
3
Create a ggplot object using world_map data.
4
Plot the geographic features using geom_sf.
5
Add points from sites data with longitude and latitude, customized size, shape, and fill colour.
6
Add repelled text labels for city names using ggrepel.
7
Apply a minimal theme to the plot.
8
Add title and axis labels.
9
Set the spatial coordinates to focus.
10
Customize the major grid lines.
11
Set the background colour to aliceblue.
12
Add a north arrow annotation at the top left of the plot.
13
Add a scale bar annotation at the bottom right of the plot.
14
Display the map.

5.2 Advanced leaflet Features

For interactive maps, leaflet offers advanced features that allow you to add layers, custom controls, and integrate with other web technologies.

Polygons and Circles

Use addPolygons() and addCircles() to highlight specific areas on your map.

Code 
leaflet_map <- leaflet::leaflet() %>%
  leaflet::addTiles() %>%
  leaflet::addMarkers(lng = -0.09, lat = 51.505, popup = "Hello, London!") %>%
  leaflet::addCircles(lng = -0.1, lat = 51.51, weight = 1, radius = 50,
             popup = "Circle around another location")
leaflet_map
1
Initialize a leaflet map object.
2
Add default OpenStreetMap tiles to the map.
3
Add a marker at the specified longitude and latitude with a popup message.
4
Add a circle at the specified longitude and latitude with a specified weight and radius.
5
Add a popup message for the circle.
6
Display the map.

These advanced features in ggplot2 and leaflet enable you to create detailed, informative, and visually appealing maps, whether they are static or interactive. By leveraging these tools, you can effectively communicate geographic data to your audience.

Common Mistakes

When creating maps in R, there are a few common mistakes that can lead to errors or unexpected results. Here are some tips to help you avoid these pitfalls:

  • Wrong Coordinates: Ensure your longitude and latitude values are correct; otherwise, your markers will not appear where expected.
  • Missing Libraries: Always load the necessary libraries before running your code.
  • Incorrect Data Types: Make sure your longitude and latitude columns are numeric. If they are factors or characters, convert them using as.numeric().
  • Mismatched Coordinate Reference Systems (CRS): Ensure your spatial data and map layers use the same CRS to avoid misalignment.
  • Overlapping Layers: Be careful with the order of layers in ggplot2. Layers added later will be on top of earlier ones, which might obscure important data.
  • Improper Aesthetics Mapping: Double-check that the aes() function correctly maps your data columns to aesthetics in ggplot2.
  • Forgetting to Print the Plot: In scripts or R Markdown documents, ensure you explicitly print the ggplot object to render the plot.
  • Large Data Sets: For very large spatial data sets, rendering can be slow. Consider simplifying your data or using more efficient packages like sf.
  • Incorrect File Paths: When loading spatial data from files, ensure the file paths are correct and the files are accessible.
  • Not Saving Plots: If you want to save your plots, use functions like ggsave() for ggplot2 maps and htmlwidgets::saveWidget() for leaflet maps.
Troubleshooting

When things go wrong, here are some troubleshooting tips to help you diagnose and fix common issues:

  • Error: Object not found: Ensure all objects (e.g., data frames, variables) are defined in your environment.
  • Map not displaying: Check your longitude and latitude values and ensure your map container is correctly set up if embedding in a Shiny app or R Markdown document.
  • Incorrect CRS: If your spatial data doesn’t align, check and transform CRS using functions like st_transform() from the sf package.
  • Slow Performance: If rendering is slow, consider reducing the complexity of your spatial data, using faster algorithms, or rendering smaller sections of the map.
  • Layer Ordering Issues: If some layers are hidden, reorder your ggplot2 layers to ensure that important data is not obscured.
  • Library Conflicts: Sometimes, functions from different libraries can conflict. Ensure you are calling functions with the correct namespace (e.g., ggplot2::geom_point()).
  • Missing Data: Check for NA values in your data, especially in critical columns like longitude and latitude. Handle missing data appropriately.
  • Plot Size: If your plot appears squished or improperly scaled, adjust the plot dimensions using ggsave() or fig.width and fig.height in R Markdown.
  • Browser Compatibility: For leaflet maps, ensure you are using a compatible web browser, and try refreshing the page if the map does not load.
  • Dependency Issues: Make sure all necessary packages and their dependencies are installed and up to date. Use install.packages() to install missing packages.
  • Resource Limits: For interactive maps, ensure your system has sufficient resources (memory, processing power) to handle large datasets and complex visualizations.

6 FAQs

Q: Can I save my interactive map as an HTML file?

A: Yes, use the saveWidget() function from the htmlwidgets package.

library(htmlwidgets)
saveWidget(m, file = "interactive_map.html")

Q: How do I add custom icons to my markers?

A: You can use the makeIcon() function to add custom icons.

custom_icon <- makeIcon(iconUrl = "path/to/icon.png", iconWidth = 30, iconHeight = 30)
leaflet_map <- leaflet::leaflet() %>%
  leaflet::addTiles() %>%
  leaflet::addMarkers(lng = -0.09, lat = 51.505, icon = custom_icon)
leaflet_map

7 Conclusion

Creating maps in R is a valuable skill for data visualization. With ggplot2, you can make static maps, and with leaflet, you can create interactive maps that provide a more engaging user experience. Experiment with different features and customization options to make your maps stand out. Happy mapping!

8 Additional Resources

Back to top

Citation

BibTeX citation:
@online{kumar jagadeesan2024,
  author = {Kumar Jagadeesan, Kishore},
  title = {Creating {Interactive} {Maps} with {R:} {A} {Beginner’s}
    {Guide} {Using} Ggplot2 and Leaflet},
  date = {2024-07-11},
  url = {https://jkkishore85.github.io/tutorials/2024-07-11-rtutorial-map-01/},
  langid = {en}
}
For attribution, please cite this work as:
Kumar Jagadeesan, Kishore. 2024. “Creating Interactive Maps with R: A Beginner’s Guide Using Ggplot2 and Leaflet.” July 11, 2024. https://jkkishore85.github.io/tutorials/2024-07-11-rtutorial-map-01/.