5 Best Ways to Find and Draw Convex Hull of an Image Contour in OpenCV Python

by

💡 Problem Formulation: In image processing and computer vision tasks, it’s often necessary to identify the convex hull of contours in an image — the smallest convex shape that fully encloses the contour. This article will guide you through five distinct methods using OpenCV in Python to locate and illustrate convex hulls, from finding contours to plotting them onto the image. Think of an image with irregular shapes, and the goal is to wrap these shapes with the tightest possible convex outline.

Method 1: Using cv2.findContours and cv2.convexHull

This method involves first detecting contours with cv2.findContours, followed by computing the convex hull of these contours using cv2.convexHull. It’s straightforward and suitable for most applications.

Here’s an example:

import cv2
import numpy as np

# Load image and convert to grayscale
image = cv2.imread('image.jpg')
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Find contours
contours, hierarchy = cv2.findContours(gray_image, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

# Find the convex hull for each contour
for cnt in contours:
    hull = cv2.convexHull(cnt)
    cv2.drawContours(image, [hull], -1, (0, 255, 0), 3)

# Display the image with convex hull
cv2.imshow('Convex Hull', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output will be the original image with green lines tracing the convex hulls around each contour.

This code snippet loads an image, identifies its contours, computes each contour’s convex hull, and then draws these hulls onto the original image. The key functions are cv2.findContours for detecting the contours and cv2.convexHull for calculating the hulls. The hulls are then drawn with cv2.drawContours.

Method 2: Simplifying Contours Before Computing Convex Hull

When contours are very complex, it might be beneficial to simplify them first using the cv2.approxPolyDP function. This can lead to faster computation and cleaner convex hull representations.

Here’s an example:

# Using the same image and contour detection as in Method 1
# Simplify contours
for cnt in contours:
    epsilon = 0.01 * cv2.arcLength(cnt, True)
    approx = cv2.approxPolyDP(cnt, epsilon, True)
    hull = cv2.convexHull(approx)
    cv2.drawContours(image, [hull], -1, (255, 0, 0), 3)

cv2.imshow('Simplified Convex Hull', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The updated output now shows contours with simplified convex hulls, potentially making the hulls clearer and easier to interpret.

This snippet adds an extra step to simplify contours before computing the convex hulls. The cv2.approxPolyDP function is used to approximate the contour shape. This approach can often benefit by reducing unnecessary points and simplifying the hull computation.

Method 3: Extracting and Using Only External Contours

Sometimes, it’s sufficient to find the convex hull of only the external contours in the image. This approach simplifies the process by ignoring all child contours using cv2.RETR_EXTERNAL during contour detection.

Here’s an example:

# Load image, convert to grayscale, and find external contours only
# Rest of the code is similar to the examples above but with cv2.RETR_EXTERNAL
contours, hierarchy = cv2.findContours(gray_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

With only external contours to consider, the output will exclude any convex hulls drawn on nested contours.

Altering the contour retrieval mode to external results in processing only the outermost contours. This leads to less complexity and quicker execution, especially if only the external shape of the objects is of interest.

Method 4: Using Contour Area Filter Before Convex Hull

To further reduce noise and focus on significant contours only, it’s possible to filter contours based on their area before calculating the convex hull with cv2.contourArea.

Here’s an example:

# Assume we already have the contours from previous methods
# Filter contours based on area and draw hulls
min_area = 100
for cnt in contours:
    if cv2.contourArea(cnt) > min_area:
        hull = cv2.convexHull(cnt)
        cv2.drawContours(image, [hull], -1, (0, 0, 255), 3)

The resulting image shows convex hulls only around contours that exceed the specified area threshold.

In this code, a contour area filter is applied to ensure only relevant contours are processed. It helps to eliminate smaller, irrelevant contours that could complicate the analysis.

Bonus One-Liner Method 5: Drawing Convex Hulls Using List Comprehension

For those comfortable with list comprehensions in Python, convex hulls can be computed and drawn succinctly in a single line nested within a display function call.

Here’s an example:

[cv2.drawContours(image, [cv2.convexHull(cnt)], -1, (0, 255, 0), 3) for cnt in contours]

This one-liner will produce an identical result to Method 1 — the original image with convex hulls of each contour drawn in green.

The compact use of a list comprehension performs contour processing in a neat one-liner. While this method is elegant, it may not be as readable for those new to Python or list comprehensions.

Summary/Discussion

  • Method 1: Direct Contour Convex Hull. Straightforward and robust. Best suited for general use, but may be slow with complex images.
  • Method 2: Simplifying Contours. Cleaner hull representations. Good for complex contours but might oversimplify and lose details.
  • Method 3: External Contour Convex Hull. Less complex, faster. Focuses only on the outer shapes, limiting information about internal structures.
  • Method 4: Area Filter Before Convex Hull. Eliminates noise. Focuses on significant shapes, but smaller details might be missed.
  • Bonus Method 5: One-Liner List Comprehension. Elegant and concise. Best for experienced Python programmers; less readable for others.