How to easily create a geographical heatmap using SAS and Python

This example shows how to create a geographical heatmap from a SASHELP.QUAKES dataset using SAS9API and Python.

Introduction

Geographical heatmaps are great visualisation tools. They show the density of points in or near a particular area. They are especially useful when you have thousands of data points and are mainly interested in their overall distribution. For example, by looking at a heatmap you can easily determine regions with high crime rates, temperatures, earthquake activity, population density, etc.

Sometimes SAS users need to create such maps. One of the ways to create a geographical heatmap is to use a gmaps plugin designed for embedding Google Maps in Jupyter notebooks and visualising data on these maps. Here we demonstrate how to easily do it.

Prerequisites

To follow the examples presented here you need to have the following:

• access to SAS9API proxy,
• Python 3 installed,
• Jupyter Notebook installed (https://jupyter.org/install),
• gmaps package for Jupyter (see below),
• Google Maps API Key (see below),
• pandas  and sas9api  Python libraries (see below).

Step 1 – Setting up the necessary tools

We need to install gmaps  package for Jupyter Notebook. The easiest way to install this package is to do it with conda  running this command in Anaconda Prompt (if you use Anaconda distribution of the Python language): conda install -c conda-forge gmaps .

(Note: you may also need to run jupyter nbextension enable –py –sys-prefix gmaps  to enable displaying of maps).

To install gmaps  with pip  do the following:

• Make sure that you have enabled ipywidgets  widgets extensions:

jupyter nbextension enable –py –sys-prefix widgetsnbextension

• You can then install gmaps  with:

pip install gmaps

• Then tell Jupyter to load the extension with the following command:

jupyter nbextension enable –py –sys-prefix gmaps  (make sure you get “Validating: ok” after running this command)

(You can find full installation instructions at https://jupyter-gmaps.readthedocs.io/en/latest/install.html).

After installing gmaps  we need to restart Jupyter Notebook.

Then we need to get Google Maps API Key by following the instructions at https://jupyter-gmaps.readthedocs.io/en/stable/authentication.html.

Python sas9api  library can be gotten at https://github.com/analytium/python-sas9api. We need to download the sas9api.py  file to our local computer. It can be done in different ways:

• using following command (if you have Git installed): git clone https://github.com/analytium/python-sas9api  to download this repository to a designated folder on a local computer;
• going to https://github.com/analytium/python-sas9api/blob/master/sas9api.py, right-clicking on the Raw button in the top right and then choosing “Save target as” to save sas9api.py  file to a local computer.

We need to place sas9api.py  file in the same folder with our Python code or provide a path to it for a successful import.

Now we are ready to start writing a Python code in Jupyter Notebook. We will use data of 10000 earthquakes from the SASHELP.QUAKES dataset to create a heatmap of regions with earthquake activity based on locations and magnitudes of these earthquakes.

Step 2 – Importing the necessary libraries

Let us import sas9api , gmaps  and pandas  libraries:

import sas9api as sas
import gmaps
import pandas as pd

Step 3 – Using a Google Maps API Key

We need to pass our Google Maps API Key to gmaps (you will need to specify your key received from Google):

gmaps.configure(api_key="your_Google_API_key")

Step 4 – Specifying SAS9API URL and port

We assign SAS9API server URL and port to a variable (you will need to assign your SAS9API URL and port):

url = "your_SAS9API_url:port"

Step 5 – Retrieving data from a SAS server

We retrieve data from the SAS server using retrieve_data  function from the sas9api  Python library.

We pass the following parameters to this function:

• url  – SAS server URL defined earlier,
• library_name  – SAS library name,
• dataset_name  – SAS dataset name,
• server_name  – SAS workspace server name,
• limit  – maximum number of records to retrieve,
• filter_  – filter to apply to the dataset: here we want to retrieve only records where Type=”earthquake”,
• only_payload  – a flag set to True to get data as a list of dictionaries containing dataset records.

dat = sas.retrieve_data(url, library_name="sashelp", dataset_name="quakes",
    limit=10000, filter_='{"Type":"earthquake"}', only_payload=True)

For a more convenient way of presenting the data we convert it to a Pandas DataFrame and then look at data.

quakes_df = pd.DataFrame(dat)
quakes_df.head()

	Depth	Latitude	Longitude	Magnitude	RootMeanSquareTime	Type	dNearestStation
0	6.2500	35.688000	-121.128670	2.75	0.0700	earthquake	0.02121
1	0.0000	41.900900	-119.622400	4.59	0.0742	earthquake	0.50700
2	0.5329	41.883600	-119.641100	3.19	0.0000	earthquake	0.49300
3	0.5077	41.889700	-119.639900	3.12	0.0119	earthquake	0.49400
4	33.5700	40.878334	-123.270332	2.60	0.0600	earthquake	0.22160

 

Now it is time to create a map!

Step 6 – Creating a geographical heatmap

Since we are dealing with earthquakes, we create a TERRAIN map (you can try other available types of maps: ROADMAP (the classic Google Maps style), SATELLITE (just satellite tiles with no overlay), HYBRID (satellite base tiles but with features such as roads and cities overlaid)).

fig = gmaps.figure(map_type='TERRAIN')

We can add different layers to this map.

First, we add a heatmap layer specifying the following parameters:

• locations  – epicentres of earthquakes defined by the Latitude and Longitude columns in our DataFrame;
• weights  – by default all points have the same weight in creating a heatmap, but we want stronger earthquakes to have more weight, so we use earthquake magnitudes as weights;
• point_radius  – “radius of influence” of each data point;
• dissipating  – a flag set to False indicating that the radius of influence of each point remains the same as you zoom in or out.

# Creating a heatmap layer
heatmap_layer = gmaps.heatmap_layer(quakes_df[['Latitude', 'Longitude']],
weights=quakes_df['Magnitude'], point_radius=1, dissipating=False)
# Adding a heatmap layer to the map
fig.add_layer(heatmap_layer)

Then we add one more layer with markers of epicentres of all earthquakes with magnitudes 5.0 and greater. To display information about a particular earthquake when we hover our mouse over its marker or click on its marker, we specify the hover_text  and info_box_content  parameters as a list of strings with the necessary information.

# Creating a new DataFrame only with earthquakes of magnitude 5.0 and greater
quakes_5plus = quakes_df[quakes_df['Magnitude'] >= 5.0]

# Creating a list of strings with the necessary information to be displayed when we hover a mouse over earthquake markers
info_5plus = [f"EARTHQUAKE:\nLatitude={str(p[1])}\nLongitude={str(p[2])}\nDepth={str(p[0])}\nMagnitude={str(p[3])}" 
    for p in quakes_5plus.values]

# Creating a layer with markers
quakes_layer = gmaps.symbol_layer(quakes_5plus[['Latitude', 'Longitude']], fill_opacity=0, stroke_color="black", scale=3, 
    hover_text=info_5plus, info_box_content=info_5plus)
# Adding a layer with markers to the map
fig.add_layer(quakes_layer)

# Showing the map
fig

After ZOOMING IN the map looks like this:

The red areas on the map are regions with high earthquake activity while the green areas are regions with low earthquake activity.

We can ZOOM IN and ZOOM OUT, move map, and hover a mouse over the markers to see the detailed information about earthquakes of magnitude 5.0 and greater (see picture below).

Conclusion

We have created a geographical heatmap showing the regions with earthquake activity. As you could see it was not a difficult process and did not require a lot of code. Now you know how to easily create beautiful heatmaps for analytical or reporting purposes using SAS and Python. There is much more to explore about creating maps:

• different types of maps;
• different layers which can be added to maps (e.g., GeoJSON, directions, bicycling, transit and traffic layers);
• ways to customise a map (width, height, layout, colour gradient and opacity, etc.);
• ways of drawing markers, lines and polygons;
• etc.

For the full list of options and different examples please refer to this documentation: https://jupyter-gmaps.readthedocs.io/en/latest/index.html.

SAS9API not only allows you to create maps and use functionality of Python, but also to use functionality of other programming languages. To find out how to use SAS9API with R language, please refer to https://sas9api.io/examples-category/r/.