# 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()
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()
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.