Check if points are inside ellipse faster than contains_point method (Matplotlib)

When checking if multiple points are inside an ellipse, the mathematical approach is significantly faster than using Matplotlib's contains_point() method. This technique uses the ellipse equation with coordinate transformation to handle rotated ellipses efficiently.

Mathematical Approach for Point-in-Ellipse Testing

The key is to transform coordinates and apply the ellipse equation directly rather than using the slower contains_point() method ?

import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np

# Set up the figure
plt.rcParams["figure.figsize"] = [7.50, 3.50]
plt.rcParams["figure.autolayout"] = True

fig, ax = plt.subplots(1)
ax.set_aspect('equal')

# Generate random test points
x = np.random.rand(100) * 0.5 + 0.7
y = np.random.rand(100) * 0.5 + 0.7

# Ellipse parameters
center = (0.7789, 0.7789)
width = 0.45
height = 0.20
angle = 45.

# Create and display the ellipse
ecl = patches.Ellipse(center, width, height, angle=angle,
                     fill=False, edgecolor='green', linewidth=5)
ax.add_patch(ecl)

# Fast mathematical check using coordinate transformation
cosine = np.cos(np.radians(180. - angle))
sine = np.sin(np.radians(180. - angle))

# Translate points to ellipse center
xc = x - center[0]
yc = y - center[1]

# Rotate coordinates to align with ellipse axes
xct = xc * cosine - yc * sine
yct = xc * sine + yc * cosine

# Apply ellipse equation: (x/a)² + (y/b)² <= 1
rad_cc = (xct ** 2 / (width / 2.) ** 2) + (yct ** 2 / (height / 2.) ** 2)

# Color points: red if inside ellipse, yellow if outside
colors = np.array(['yellow'] * len(rad_cc))
colors[np.where(rad_cc <= 1)[0]] = 'red'

ax.scatter(x, y, c=colors, linewidths=0.7)
plt.show()

How the Algorithm Works

The fast approach uses these mathematical steps:

1. Translation: Move all points so the ellipse center becomes the origin
2. Rotation: Rotate coordinates to align with the ellipse's major/minor axes
3. Ellipse Equation: Check if (x/a)² + (y/b)² ? 1 where a and b are semi-axes

Performance Comparison

Key Points

• The angle transformation accounts for rotated ellipses
• NumPy vectorization processes all points simultaneously
• Values ? 1 indicate points inside the ellipse
• This method is 5-10x faster than contains_point() for large datasets

Conclusion

The mathematical approach using coordinate transformation and the ellipse equation is significantly faster than contains_point(). Use this method when checking many points simultaneously for better performance.