Filling Areas within a Polygon in Python Using Matplotlib

Rate this post

πŸ’‘ Problem Formulation: When visualizing data or providing graphical representations, one might need to emphasize specific areas within a plot by filling in polygons. In Python, using Matplotlib, this can be accomplished in various ways. For example, if given the vertices of a pentagon, the desired output would be a plot with the pentagon filled in a color of choice, showing clear demarcation of that area from the rest of the plot.

Method 1: Using the fill() function

Matplotlib’s fill() function allows you to fill the area of a polygon by specifying the vertices. The function takes in the x and y coordinates of the polygon’s vertices and an optional color to fill the polygon. This method provides a straightforward way to fill in simple polygons quickly.

Here’s an example:

import matplotlib.pyplot as plt

# Coordinates of the vertices of the polygon
x = [1, 2, 3, 2, 1]
y = [1, 3, 1, 0, 1]

plt.fill(x, y, color='skyblue')
plt.plot(x, y, color='blue')  # Optional: plot the outline
plt.show()

This code snippet creates a plot with a sky-blue filled pentagon.

The example demonstrates creating a pentagon by specifying the coordinates of its vertices to fill(), with the ‘skyblue’ color filling the inside of the polygon. The plot() function is also used to draw the outline of the pentagon for better visual contrast.

Method 2: Using the fill_between() function

For filling area between two horizontal curves, Matplotlib provides the fill_between() function. This is effective for shading areas under a line graph, between two lines, or between a line and a constant (like the x-axis).

Here’s an example:

import numpy as np
import matplotlib.pyplot as plt

# Creating the x-axis values and two y-axis values to fill between
x = np.linspace(0, 2 * np.pi, 500)
y1 = np.sin(x)
y2 = np.sin(3 * x)

plt.fill_between(x, y1, y2, color='violet', alpha=0.5)
plt.plot(x, y1, x, y2, color='darkviolet')
plt.show()

This code snippet fills the area between two sine waves with a violet color.

This method leverages the fill_between() function to fill the area between the curve y1 = np.sin(x) and y2 = np.sin(3 * x) with semi-transparent violet color, giving it a nice visual effect.

Method 3: Using the Polygon class

The Polygon class from Matplotlib’s patches module allows for more control and customization when creating and filling polygons. You can instantiate a Polygon object with the list of vertices and additional style parameters.

Here’s an example:

import matplotlib.pyplot as plt
import matplotlib.patches as patches

# Coordinates of the vertices of the polygon
polygon_coords = [(1, 1), (2, 3), (3, 1), (2, 0)]

# Creating a Polygon patch
polygon = patches.Polygon(polygon_coords, closed=True, facecolor='limegreen', edgecolor='forestgreen')

# Adding the patch to the current axes
ax = plt.gca()
ax.add_patch(polygon)
plt.axis('scaled')
plt.show()

This code snippet creates a plot with a lime-green filled polygon with a forest-green edge.

In the example, a Polygon patch is created with the specified vertices and color attributes. It is then added to the current Axes object using add_patch() method. Using the Polygon class allows for extensive customization and is more appropriate for complex shapes and figures.

Method 4: Using PathPatch from the path Module

PathPatch objects from the Matplotlib’s path module are similar to Polygon patches but offer a different interface that can be more convenient for complex paths. It allows you to create a polygon by defining a path and a patch from that path.

Here’s an example:

import matplotlib.pyplot as plt
from matplotlib.path import Path
import matplotlib.patches as patches

verts = [(1, 1), (2, 3), (3, 1), (2, 0), (1, 1)]
codes = [Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY]

path = Path(verts, codes)
patch = patches.PathPatch(path, facecolor='orange', lw=2)

ax = plt.gca()
ax.add_patch(patch)
plt.axis('scaled')
plt.show()

This code snippet draws an orange filled polygon created from a path.

By defining the vertices and codes for how the path should be constructed, PathPatch allows for more sophisticated paths. The path is converted into a patch which is added to the plot. The code snippet illustrates a flexible way to define and fill complex shapes.

Bonus One-Liner Method 5: Using plt.fill() with Star Expansion

Python’s star expansion can be deployed in combination with matplotlib’s plt.fill() function for a concise one-liner to fill a polygon given a list of coordinate tuples.

Here’s an example:

import matplotlib.pyplot as plt

# List of coordinates
polygon_coords = [(1, 1), (2, 3), (3, 1), (2, 0), (1, 1)]

plt.fill(*zip(*polygon_coords), color='gold')
plt.show()

This code snippet quickly fills a polygon with a gold color.

The *zip(*polygon_coords) syntax unpacks and transposes the list of tuples into separate x and y coordinate sequences, which are passed to plt.fill(). This one-liner is handy for quickly filling polygons when the coordinates list is already available.

Summary/Discussion

  • Method 1: Using fill(). Simple and effective for basic shapes. Limited to non-complex polygons.
  • Method 2: Using fill_between(). Ideal for filling areas between lines, particularly in line plots. Not suitable for arbitrary polygons.
  • Method 3: Using the Polygon class. Offers customization and control. Can be overkill for simple tasks.
  • Method 4: Using PathPatch. Best for complex figures and intricate paths. More verbose than simple fill().
  • Bonus Method 5: One-Liner with star expansion. Most succinct for quick plotting. Requires understanding of Python’s unpacking features.