Introduction

Detecting quadrilaterals is a common computer-vision task because many real objects project to four-sided shapes: documents, screens, road signs, cards, and boxes. A practical quadrilateral finder usually combines image preprocessing, contour extraction, polygon approximation, and geometric validation rather than trying to classify pixels directly.

A Reliable Detection Pipeline

A good algorithm does not begin by asking, "is this a rectangle?" It first isolates strong edges and closed contours, then narrows the candidates.

A typical pipeline looks like this:

1. convert the image to grayscale
2. reduce noise with blur
3. detect edges
4. find contours
5. approximate each contour as a polygon
6. keep polygons with four vertices and sensible geometry

That separation is useful because each stage removes a different class of false positives.

A Runnable OpenCV Example

The example below finds convex four-sided contours and filters out tiny shapes.

1import cv2
2import numpy as np
3
4
5def find_quadrilaterals(image_path: str):
6    image = cv2.imread(image_path)
7    if image is None:
8        raise FileNotFoundError(image_path)
9
10    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
11    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
12    edges = cv2.Canny(blurred, 75, 200)
13
14    contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
15    quads = []
16
17    for contour in contours:
18        perimeter = cv2.arcLength(contour, True)
19        approx = cv2.approxPolyDP(contour, 0.02 * perimeter, True)
20        area = cv2.contourArea(approx)
21
22        if len(approx) == 4 and cv2.isContourConvex(approx) and area > 1000:
23            quads.append(approx)
24
25    for quad in quads:
26        cv2.drawContours(image, [quad], -1, (0, 255, 0), 2)
27
28    return image, quads
29
30
31if __name__ == "__main__":
32    result, quads = find_quadrilaterals("input.jpg")
33    print(f"found {len(quads)} quadrilateral candidates")
34    cv2.imwrite("output.jpg", result)

This is a practical starting point for document scanners or shape-highlighting tools. It is not magic, but it covers the main steps that matter.

Why Polygon Approximation Matters

Contours often contain dozens or hundreds of points. cv2.approxPolyDP simplifies that contour to a smaller polygon while preserving the outline within a tolerance.

The tolerance value controls how aggressively the shape is simplified. A value around 0.01 to 0.03 times the contour perimeter is a common starting range. Too small and you keep noisy points. Too large and you collapse real corners.

For quadrilateral detection, this approximation stage is what turns a ragged contour into a testable "does it have four corners" candidate.

Add Geometric Checks Beyond Four Vertices

Not every four-vertex polygon is useful. Depending on the application, you may want extra tests:

• minimum area, to reject tiny noise blobs
• convexity, to reject self-folded or concave shapes
• angle similarity, if you expect rectangles
• aspect-ratio limits, if the target object has known proportions

A document scanner, for example, often expects a large convex quadrilateral near the center of the frame. A generic shape detector may want to keep more candidates and let later stages rank them.

If you need rectangle-like shapes specifically, you can estimate the angle between adjacent edges and discard candidates whose corners are far from right angles.

Perspective and Ordering of Corners

Real images rarely show perfect front-facing rectangles. Perspective distortion can turn a rectangle into a general convex quadrilateral, which is why a four-corner detector is often better than a strict rectangle detector.

Once a quadrilateral is found, the next useful step is ordering the corners consistently, usually top-left, top-right, bottom-right, bottom-left. That allows you to compute a perspective transform and warp the region into a flat view for OCR or downstream analysis.

So in many applications, "find a quadrilateral" is really the front half of a document-normalization pipeline.

Common Pitfalls

Using thresholds that are too aggressive can erase valid edges before contour detection even begins. Tune blur, Canny thresholds, and minimum area together rather than independently.

Assuming the largest contour is always the correct one also causes false detections in cluttered scenes.

Ignoring convexity can admit bizarre four-point approximations that are not useful target shapes.

Finally, do not expect one fixed tolerance value to work for every image scale. Contour approximation parameters often need to be chosen relative to perimeter or image size.

Summary

• quadrilateral detection is usually built from preprocessing, contour extraction, polygon approximation, and geometric filtering
• 'cv2.approxPolyDP is the key step that converts dense contours into corner candidates'
• four vertices alone are not enough; area and convexity checks remove many false positives
• perspective distortion means many real rectangles appear as general quadrilaterals in the image
• the detected corners are often used next for perspective correction or document warping