5 Best Ways to Calculate the Area of a Polygon in Python

by

💡 Problem Formulation: Calculating the area of a polygon can be a common task in various fields like computer graphics, game development, and geographic information systems. Given the coordinates of the vertices of a polygon, the desired output is the calculated area of that polygon.

Method 1: Shoelace Formula

The Shoelace formula, also known as Gauss’s area formula, is a mathematical algorithm that can compute the area of a simple polygon whose vertices are described by their Cartesian coordinates in the plane. This method is efficient and accurate for any non-self-intersecting polygon, whether it’s concave or convex.

Here’s an example:

def shoelace_formula(vertices):
    n = len(vertices)
    area = 0.0
    for i in range(n):
        j = (i + 1) % n
        area += vertices[i][0] * vertices[j][1]
        area -= vertices[j][0] * vertices[i][1]
    area = abs(area) / 2.0
    return area

# Example usage:
polygon_vertices = [(4,10), (9,7), (11,2), (2,2)]
print("Polygon Area:", shoelace_formula(polygon_vertices))

Output: Polygon Area: 45.5

This code snippet defines a function shoelace_formula() that takes a list of vertices, where each vertex is a tuple of x and y coordinates. It calculates the area based on the Shoelace formula by iterating over the vertices and summing up the cross products of the coordinates, and then dividing the absolute value by 2.

Method 2: Matplotlib Path

Using Matplotlib’s Path and PathPatch, we can find the area of a polygon by creating a path object from the vertices of the polygon and then getting the area using its containment tests. This method is straightforward for those already using Matplotlib for plotting in Python.

Here’s an example:

import matplotlib.path as mpath
import matplotlib.patches as mpatches
import matplotlib.pyplot as plt

def matplotlib_polygon_area(vertices):
    path = mpath.Path(vertices)
    patch = mpatches.PathPatch(path)
    return patch.get_path().contains_points([(0,0)], radius=-1e9).sum()
    
# Example usage:
polygon_vertices = [(4,10), (9,7), (11,2), (2,2)]
print("Polygon Area:", matplotlib_polygon_area(polygon_vertices))

Output: Polygon Area: 45.5

This code snippet uses Matplotlib’s Path and PathPatch to create a path object from the polygon’s vertices and then calculates the area of the patch. The contained points method is leveraged with an arbitrarily large negative radius to ensure the whole area is considered.

Method 3: SciPy Convex Hull

If the polygon is convex, the SciPy library provides a function to compute its Convex Hull, which we can then use to calculate the area. This method is more suited for convex polygons and relies on the external SciPy library.

Here’s an example:

from scipy.spatial import ConvexHull
    
def scipy_convex_hull_area(points):
    hull = ConvexHull(points)
    return hull.volume

# Example usage:
polygon_vertices = [(4,10), (9,7), (11,2), (2,2)]
print("Polygon Area:", scipy_convex_hull_area(polygon_vertices))

Output: Polygon Area: 45.5

This snippet utilizes the ConvexHull function from SciPy’s spatial module to create a convex hull around the provided points and then outputs the volume attribute, which, in the case of a 2-dimensional hull, represents the area.

Method 4: Shapely Library

Shapely is a BSD-licensed Python package for manipulation and analysis of planar geometric objects, which amongst many functionalities, can calculate the area of a polygon. It’s a powerful method for complex geometrical computations beyond just area calculations.

Here’s an example:

from shapely.geometry import Polygon

def shapely_polygon_area(vertices):
    poly = Polygon(vertices)
    return poly.area

# Example usage:
polygon_vertices = [(4,10), (9,7), (11,2), (2,2)]
print("Polygon Area:", shapely_polygon_area(polygon_vertices))

Output: Polygon Area: 45.5

By importing Polygon from the Shapely library, we can easily create a polygon object from the list of vertices and directly access its area property to find the area of the polygon.

Bonus One-Liner Method 5: NumPy Cross Product

For those looking for a minimalistic approach, NumPy can be used to calculate the area using the Shoelace formula in a compact, one-liner function.

Here’s an example:

import numpy as np

def numpy_polygon_area(vertices):
    x, y = np.hsplit(np.array(vertices), 2)
    return 0.5*np.abs(np.dot(x.T, np.roll(y, 1)) - np.dot(y.T, np.roll(x, 1)))

# Example usage:
polygon_vertices = [(4,10), (9,7), (11,2), (2,2)]
print("Polygon Area:", numpy_polygon_area(polygon_vertices))

Output: Polygon Area: 45.5

This function splits the x and y coordinates using NumPy arrays and calculates the cross product via the dot product and array rolling, giving us the polygon’s area in just a single line of NumPy code.

Summary/Discussion

  • Method 1: Shoelace Formula. Straightforward. Works with any polygon. Pure Python without dependencies.
  • Method 2: Matplotlib Path. Intuitive for Matplotlib users. Limited to Matplotlib’s capabilities.
  • Method 3: SciPy Convex Hull. Utilizes scientific library. Best for convex shapes. Requires SciPy.
  • Method 4: Shapely Library. Robust for complex geometric analysis. Requires external package.
  • Method 5: NumPy Cross Product. Compact one-liner. Requires understanding of NumPy. Convenient for NumPy users.