pontalk: Explore Python's Hidden Treasures!

Charting the World: Visualizing Geographic Data with Matplotlib and Cartopy

Written by

ken

in

Have you ever looked at a map and wondered how all that intricate data, from city locations to ocean depths, gets translated into a beautiful, insightful image? Geographic data visualization is a powerful way to understand our world, identify patterns, and tell compelling stories. If you’re new to the world of data science or just curious about making maps with code, you’re in the right place!

In this blog post, we’re going to dive into how you can visualize geographic data using two fantastic Python libraries: Matplotlib and Cartopy. Matplotlib is your go-to tool for creating a wide variety of plots, and Cartopy is a specialized extension that makes working with maps a breeze.

What Exactly is Geographic Data?

Simply put, geographic data is any information that has a connection to a specific location on Earth. Think about it:
* The latitude and longitude coordinates of your favorite restaurant.
* The boundaries of countries or states.
* The path of a hurricane across an ocean.
* The distribution of population density across a city.

This kind of data is all about “where” things are and how they relate to each other spatially.

Why Visualize Geographic Data?

Visualizing geographic data isn’t just about making pretty pictures; it’s about making sense of complex information. Here’s why it’s so important:

  • Spotting Patterns: Maps make it easy to see trends or clusters that might be hidden in tables of numbers. For example, plotting crime rates on a map can highlight high-risk areas.
  • Storytelling: A well-designed map can communicate a story much more effectively than text or raw data. Think about election results maps or climate change visualizations.
  • Decision Making: Businesses use geographic data to decide where to open new stores, governments use it for urban planning, and scientists use it to track environmental changes.
  • Accessibility: Visual representations are often easier for a broader audience to understand than technical reports or spreadsheets.

Getting Started: Your Mapping Toolkit

To embark on our map-making journey, we’ll need a couple of essential Python libraries.

  • Matplotlib: This is the foundational plotting library in Python. It’s like a versatile drawing board that allows you to create static, animated, and interactive visualizations in Python.
  • Cartopy: This is a specialized library built on top of Matplotlib, designed specifically for creating maps and performing geographic data processing. It handles tricky things like map projections and adding geographical features (like coastlines and country borders) with ease.

Installation

If you don’t have these installed already, you can get them using pip, Python’s package installer:

pip install matplotlib cartopy

A quick note: Sometimes, cartopy can be a bit tricky to install on certain systems due to underlying dependencies. If you encounter issues, using a package manager like conda (e.g., conda install -c conda-10.4 cartopy) or checking Cartopy’s official installation guide can be helpful.

Basic Geographic Concepts for Beginners

Before we draw our first map, let’s quickly touch upon two fundamental concepts:

  • Coordinates (Latitude and Longitude):

    • Latitude: Imagine horizontal lines running around the Earth, parallel to the equator. Latitude measures how far north or south a point is from the equator. The equator is 0 degrees, the North Pole is 90 degrees North, and the South Pole is 90 degrees South.
    • Longitude: Imagine vertical lines (meridians) running from pole to pole. Longitude measures how far east or west a point is from the Prime Meridian (which runs through Greenwich, London, and is 0 degrees). Longitude ranges from 180 degrees West to 180 degrees East.
    • Together, latitude and longitude give every point on Earth a unique address!

  • Map Projections:

    • The Earth is a sphere (or, more accurately, an oblate spheroid – a slightly flattened sphere). When we try to represent this 3D surface on a flat, 2D map, some distortion is inevitable.
    • A map projection is a mathematical method used to transform points from the Earth’s curved surface onto a flat plane.
    • Different projections emphasize different qualities. Some preserve area accurately, others maintain shape, distance, or direction. No single projection can perfectly preserve all of these simultaneously.
    • For beginners, the PlateCarree projection (which we’ll use) is very common and straightforward, essentially treating latitude and longitude as a simple grid, though it does distort areas towards the poles.

Your First Geographic Map with Cartopy

Let’s create a simple map of the world and plot a few cities on it.

Step 1: Import Necessary Libraries

First, we need to bring in the tools we’ll use:

import matplotlib.pyplot as plt
import cartopy.crs as ccrs
import cartopy.feature as cfeature
  • matplotlib.pyplot as plt: This is the standard way to import Matplotlib’s plotting interface.
  • cartopy.crs as ccrs: crs stands for Coordinate Reference System. This module contains different map projections (like PlateCarree).
  • cartopy.feature as cfeature: This module provides access to common geographical features like coastlines, country borders, oceans, and landmasses.

Step 2: Set Up the Map Canvas

Now, let’s create a figure (the entire window where the plot appears) and an axes object (the actual plot area) that understands geographic coordinates.

fig = plt.figure(figsize=(10, 8)) # Create a figure, specify its size (width, height in inches)
ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree())
  • plt.figure(): Creates a new figure. figsize makes it a good size for viewing.
  • fig.add_subplot(): Adds a subplot to our figure. The 1, 1, 1 means 1 row, 1 column, and this is the first subplot. The magic happens with projection=ccrs.PlateCarree(), which tells Matplotlib to interpret the data using this specific geographic projection.

Step 3: Add Base Map Features

Let’s make our map look like a map by adding land, oceans, coastlines, and country borders.

ax.add_feature(cfeature.LAND)         # Add landmasses
ax.add_feature(cfeature.OCEAN)        # Add oceans
ax.add_feature(cfeature.COASTLINE)    # Add coastlines
ax.add_feature(cfeature.BORDERS, linestyle=':') # Add country borders with a dotted line
  • ax.add_feature(): This method adds predefined geographic features to our map from the cfeature module. It’s super handy!

Step 4: Define and Plot Data Points

Now, let’s plot some specific locations, like major cities. We’ll need their latitude and longitude.

cities = [
    [-0.1278, 51.5074, "London"],    # London, UK
    [-74.0060, 40.7128, "New York"], # New York City, USA
    [2.3522, 48.8566, "Paris"],      # Paris, France
    [139.6917, 35.6895, "Tokyo"],    # Tokyo, Japan
    [151.2093, -33.8688, "Sydney"]   # Sydney, Australia
]

lon = [city[0] for city in cities]
lat = [city[1] for city in cities]
names = [city[2] for city in cities]

ax.plot(lon, lat, 'o', color='red', markersize=8, transform=ccrs.PlateCarree())

for i, city_name in enumerate(names):
    ax.text(lon[i] + 3, lat[i] + 1, city_name,
            color='blue', fontsize=10, transform=ccrs.PlateCarree())
  • ax.plot(): This is Matplotlib’s standard plotting function. When used with a Cartopy axes, it plots geographic points.
  • transform=ccrs.PlateCarree(): This is a very important argument! It specifies the Coordinate Reference System (CRS) of the data you are plotting. Even though our map is PlateCarree, if your data was in a different projection (e.g., UTM), you would specify that here. Since our lon and lat are standard longitude and latitude values, they are naturally in the PlateCarree CRS.
  • ax.text(): Adds text labels to the map.

Step 5: Customize the Map

Let’s add a title and gridlines to make our map more informative.

ax.set_title("World Map with Selected Cities") # Give our map a title
gl = ax.gridlines(draw_labels=True, linestyle='--', color='gray', alpha=0.5)
gl.xlabels_top = False # Don't show longitude labels at the top
gl.ylabels_right = False # Don't show latitude labels on the right
  • ax.set_title(): Sets the title for the plot.
  • ax.gridlines(): Adds lines of constant latitude and longitude (meridians and parallels). draw_labels=True displays the numerical values along the edges.

Step 6: Display the Map!

Finally, show your masterpiece!

plt.show() # Display the map

Full Code Example:

import matplotlib.pyplot as plt
import cartopy.crs as ccrs
import cartopy.feature as cfeature

fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree())

ax.add_feature(cfeature.LAND, color='lightgray')
ax.add_feature(cfeature.OCEAN, color='lightblue')
ax.add_feature(cfeature.COASTLINE, linewidth=0.8)
ax.add_feature(cfeature.BORDERS, linestyle=':', edgecolor='gray')

cities = [
    [-0.1278, 51.5074, "London"],
    [-74.0060, 40.7128, "New York"],
    [2.3522, 48.8566, "Paris"],
    [139.6917, 35.6895, "Tokyo"],
    [151.2093, -33.8688, "Sydney"]
]

lon = [city[0] for city in cities]
lat = [city[1] for city in cities]
names = [city[2] for city in cities]

ax.plot(lon, lat, 'o', color='red', markersize=8, transform=ccrs.PlateCarree())

for i, city_name in enumerate(names):
    # Adjust label position slightly to avoid overlapping the marker
    ax.text(lon[i] + 2, lat[i] + 0.5, city_name,
            color='blue', fontsize=10, transform=ccrs.PlateCarree())

ax.set_title("World Map with Selected Cities", fontsize=16)
gl = ax.gridlines(draw_labels=True, linestyle='--', color='gray', alpha=0.5)
gl.xlabels_top = False
gl.ylabels_right = False
gl.xlabel_style = {'size': 10, 'color': 'black'}
gl.ylabel_style = {'size': 10, 'color': 'black'}


plt.show()

A Note on Different Projections

While PlateCarree is great for simple world maps, Cartopy offers many other projections. Each projection serves a specific purpose, minimizing different types of distortion. For instance:

  • ccrs.Mercator(): Famous for navigation charts, but greatly distorts areas near the poles (e.g., Greenland appears massive).
  • ccrs.Robinson(): A good general-purpose projection for world maps that visually balances shape and area distortion.
  • ccrs.Orthographic(): Creates a “globe” view, like looking at the Earth from space.

To try a different projection, just change the projection argument when creating your axes:

ax_robinson = fig.add_subplot(1, 1, 1, projection=ccrs.Robinson())

Experimenting with projections can drastically change how your map looks and what message it conveys!

Beyond Basic Plots

This introduction just scratches the surface of what’s possible with Matplotlib and Cartopy:

  • Plotting Paths: Visualize flight routes, migration patterns, or shipping lanes by plotting lines between geographic points.
  • Coloring Regions: Color entire countries or states based on data (e.g., population, GDP). This often involves working with GeoJSON files or similar spatial data formats.
  • Heatmaps: Show density or intensity of data over a geographic area.
  • Interactive Maps: While Matplotlib creates static images, it can be integrated with tools like Folium or Plotly for interactive web-based maps.

Conclusion

Visualizing geographic data is an incredibly rewarding skill, allowing you to transform raw coordinates and figures into insightful, understandable maps. With Matplotlib providing the plotting foundation and Cartopy offering specialized geographic capabilities, you have a powerful duo at your fingertips.

We’ve covered the basics: understanding geographic data, setting up your environment, grasping core concepts like coordinates and projections, and creating your very first interactive map. This is just the beginning! I encourage you to experiment with different data, explore various Cartopy features and projections, and see what stories your maps can tell. Happy mapping!

Comments

Leave a Reply

More posts