GeoPandas offers an intuitive way to create interactive maps through its explore() method. In this tutorial, we’ll dive into how to use this method to visualize and analyze Australian states and territories, while also touching on some important concepts in geographic data representation.

Setting Up Our Environment

First, let’s import the necessary libraries and load our dataset:

import geopandas as gpd
import geodatasets

# Load the Australia States and Territories dataset
path = geodatasets.get_path('abs.australia_states_territories')
australia = gpd.read_file(path)

# Remove the 'Outside Australia' row as it has no geometry
australia = australia.dropna(subset=['geometry'])

This dataset contains information about Australian states and territories, including their names, codes, and geometric boundaries.

Creating a Basic Interactive Map

Let’s start with a simple interactive map of Australia:

australia.explore(
    column="STE_NAME21",
    tooltip=["STE_NAME21", "AREASQKM21"],
    popup=True,
    title="Australian States and Territories"
)

This code creates an interactive map where each state/territory is colored differently. When you hover over a region, you’ll see its name and area. Clicking on a region will show all available information about it.

The power of the explore() method lies in its simplicity. With just a few lines of code, we’ve created a fully interactive map that allows users to zoom, pan, and explore the data.

Understanding Polygon vs MultiPolygon

As we work with this data, you might notice that most of our geometries are of type MULTIPOLYGON, with only the Australian Capital Territory represented as a simple POLYGON. Let’s explore this difference:

# Display geometry types
print(australia['geometry'].geom_type.value_counts())

# Plot ACT separately
act = australia[australia['STE_NAME21'] == 'Australian Capital Territory']
act.explore(
    tooltip="STE_NAME21",
    color="red",
    title="Australian Capital Territory (POLYGON)"
)

A POLYGON represents a single closed shape with a boundary and interior. It’s suitable for contiguous land areas like the ACT.

A MULTIPOLYGON, on the other hand, is a collection of multiple POLYGONs. It’s used for regions that consist of multiple, disconnected areas. In our dataset, most states and territories are represented as MULTIPOLYGONs because they include both mainland areas and offshore islands or territories.

For example, Western Australia (WA) includes offshore territories like the Ashmore and Cartier Islands. To visualize this, let’s create a map highlighting Western Australia:

australia['geometry_count'] = australia['geometry'].apply(lambda x: len(x.geoms) if x.geom_type == 'MultiPolygon' else 1)

wa = australia[australia['STE_NAME21'] == 'Western Australia']
wa.explore(
    tooltip=['STE_NAME21', 'geometry_count'], 
    color="yellow",
    title="Western Australia (MULTIPOLYGON)"
)

This map showcases Western Australia in yellow. When you explore this map, pay attention to the following:

1. Zoom out to see the full extent of Western Australia, including its offshore territories.
2. Notice the small, disconnected polygons representing islands and offshore areas.
3. The tooltip now includes both the state name and the ‘geometry_count’, which indicates the number of separate polygons that make up Western Australia.
4. Try zooming in on the coastline and offshore areas. You’ll see numerous small islands and detached territories, each represented as a separate polygon within the MultiPolygon structure.

The contrast between the single-polygon ACT (shown in red in the previous map) and the multi-polygon Western Australia (shown in yellow here) highlights the range of geographic complexity across Australian states and territories. It also underscores the importance of using appropriate data structures like MultiPolygons to accurately represent diverse geographic features.

Handling MultiPolygons in Analysis

When working with MultiPolygons, it’s important to consider how they might affect your analysis:

1. Area Calculations: The area of a MultiPolygon is the sum of its constituent polygons’ areas. This correctly accounts for all territories, including small offshore islands.
2. Centroid Calculations: Each polygon within a MultiPolygon will have its own centroid, which can lead to multiple points for a single state/territory.
3. Boundary Operations: Operations like buffering or simplification need to consider all parts of a MultiPolygon.

To further our understanding of MultiPolygons, let’s calculate and display the number of geometries for each state/territory:

australia.explore(
    column='geometry_count',
    legend=True,
    scheme='naturalbreaks',
    tooltip=['STE_NAME21', 'geometry_count'],
    popup=True,
    title='Number of Geometries per State/Territory'
)

This map shows how many separate geometries make up each state or territory, giving us insight into the complexity of their boundaries. States with higher counts likely include more offshore islands or detached territories.

As we can see from the visualization, there’s a wide range in the number of geometries across different states and territories. The Australian Capital Territory (ACT) stands out with its single polygon, while Western Australia has the highest number of geometries, indicating a complex coastline and numerous offshore islands and territories.

Conclusion

The explore() method in GeoPandas provides a powerful and flexible way to create interactive maps. It allows us to quickly visualize complex geospatial data, like the varied territories of Australia, with just a few lines of code.

Through this exploration, we’ve not only learned how to create informative, interactive maps but also gained insight into how geographic data is represented. The distinction between POLYGONs and MULTIPOLYGONs reflects the complex nature of real-world geographic boundaries, especially for a country like Australia with its numerous offshore territories.

As you continue to work with GeoPandas, remember that understanding these underlying data structures is essential for accurate analysis and visualization. The explore() method provides an excellent tool for initial data exploration, allowing you to quickly grasp the nature of your geospatial data and share your insights in an interactive, engaging format.