Finding the Shortest and Longest Average Distances

Instead of a map, what if we want to find the average travel distance for a school? Or find which schools have the shortest and longest averages? The following code will do these using the previous df DataFrame and techniques like the great_circle() method that we used before:

# Calculate average distances between each school and the others
coords = df[['latitude', 'longitude']].to_numpy()
distance_matrix = np.zeros((len(coords), len(coords)))
for i in range(len(coords)):
    for j in range(len(coords)):
        distance_matrix[i, j] = great_circle((coords[i][0], coords[i][1]), 
                                             (coords[j][0], coords[j][1])).miles
avg_distances = distance_matrix.mean(axis=1)
shortest_avg_distance_school = df['school'].iloc[avg_distances.argmin()]
longest_avg_distance_school = df['school'].iloc[avg_distances.argmax()]
print(f"School with shortest average distance: {shortest_avg_distance_school}")
print(f"School with longest average distance: {longest_avg_distance_school}")

School with shortest average distance: Miss State
School with longest average distance: Texas

Mississippi State University, near the center of the SEC, has the shortest average travel distance (320 miles). The University of Texas, on the far western edge of the conference, has the longest (613 miles).

NOTE: These average distances do not take into account annual schedules. There aren’t enough games in a season for all the teams to play each other, so the averages in a given year may be shorter or longer than the ones calculated here. Over three-year periods, however, each school will rotate through all the conference teams.

Finding the Minimum Distance to an SEC School

Remember at the start of this article I mentioned a distance-to-the-nearest-national-park map? Now I’ll show you how to make one of these, only we’ll use SEC schools in place of parks.

All you have to do is take our previous code and replace the “calculate distances” block with this snippet (plus adjust the plot’s title text):

# Calculate minimum distance to any school from every point in the grid:
distances = np.zeros(xx.shape)
for i in range(xx.shape[0]):
    for j in range(xx.shape[1]):
        point_coords = (yy[i, j], xx[i, j])
        distances[i, j] = min(great_circle(point_coords, 
                                           (df.loc[k, 'latitude'], 
                                            df.loc[k, 'longitude'])).miles 
                                   for k in range(len(df)))

This may take a few minutes, so be patient (or drop the resolution on the grid before running).

For a more ascetic map, expand the size of the grid by making this edit:

# Create grid of points for interpolation
x_min, x_max = -107, -75
y_min, y_max = 23.5, 42.5 
xx, yy = np.meshgrid(np.linspace(x_min, x_max, RESOLUTION), 
                     np.linspace(y_min, y_max, RESOLUTION))

And adjust the lat-lon dimensions for the state boundaries with this substitution:

# Filter states within the map limits
states = states.cx[-100:-80, 25:36.5]

Here’s the result:

There are more fancy things we can do, such as manually removing states not in the SEC and clipping the contoured map to the outer state boundaries. But I’m tired now, so those are tasks for another article!

Gridding and Contouring Other Continuous Data

In the previous examples, we started with location data and calculated “distance from” directly from the map coordinates. In many cases, you’ll have additional data, such as temperature measurements, that you’ll want to contour.

Here’s an example script for doing this, built off what we did before. I’ve replaced the school names with temperatures in degrees Fahrenheit. I’ve also used SciPy to grid the data, as a change of pace.

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import geopandas as gpd
from scipy.interpolate import griddata
# Load the temperature data:
data = {
    'temp': [90, 94, 89, 90, 
             91, 87, 85, 84, 
             87, 95, 90, 83, 
             88, 95, 96, 90],
    'latitude': [33.209, 30.412, 34.365, 33.456, 
                 32.603, 36.068, 38.951, 36.162,
                 35.960, 29.651, 33.950, 38.049, 
                 34.000, 30.620, 30.284, 35.222],
    'longitude': [-87.538, -91.177, -89.526, -88.811, 
                  -85.484, -94.172, -92.328, -86.784,
                  -83.920, -82.324, -83.377, -84.500, 
                  -81.034, -96.340, -97.740, -97.445]
}
df = pd.DataFrame(data)
# Generate grid data
x_min, x_max = df['longitude'].min(), df['longitude'].max()
y_min, y_max = df['latitude'].min(), df['latitude'].max()
grid_lat, grid_lon = np.mgrid[y_min:y_max:100j, x_min:x_max:100j]
grid_temp = griddata((df.latitude, df.longitude), 
                     df.temp, (grid_lat, grid_lon), 
                     method='cubic')
# Create plot
fig, ax = plt.subplots(figsize=(10, 7))
contour = ax.contourf(grid_lon, grid_lat, grid_temp, cmap='coolwarm')
plt.colorbar(contour, ax=ax, label='Temperature (°F)')
# Load state boundaries from US Census Bureau
url = 'https://www2.census.gov/geo/tiger/GENZ2021/shp/cb_2021_us_state_20m.zip'
states = gpd.read_file(url)
# Filter states within the map limits
states = states.cx[x_min:x_max, y_min:y_max]
# Plot the state boundaries
states.boundary.plot(ax=ax, linewidth=1, edgecolor='black')
# Add data points and labels
scatter = ax.scatter(df.longitude, df.latitude, 
                     c='black', 
                     edgecolors='white', 
                     s=10)
for i, row in df.iterrows():
    ax.text(row['longitude'], row['latitude'], 
            f"{round(row['temp'])}°F", 
            fontsize=8, 
            ha='right', 
            color='k')
# Set labels and title
ax.set_xlabel('Longitude')
ax.set_ylabel('Latitude')
ax.set_title('Temperature Contours')
plt.savefig('temperature_map.png', dpi=600)
plt.show()

Here’s the resulting temperature map:

This technique works well for any continuously and smoothly varying data, such as temperature, precipitation, population, etc.

Summary

Contouring data on maps is common practice for many professions, including geology, meteorology, economics, and sociology. In this article, we used a slew of Python libraries to make maps of the distance from specific colleges, and then from multiple colleges. We also looked at ways to grid and contour other continuous data, such as temperature data.

Thanks!

Thanks for reading and please follow me for more Quick Success Data Science projects in the future.