Match Descriptors Between Two Views

Welcome to Unit 4 of our course. Up to this point, you have learned how to preprocess images and extract visual fingerprints by detecting keypoints and computing their descriptors.

Now, we are ready to tackle the first real dependency in our image stitching pipeline: feature matching. Finding keypoints in an isolated image is a great start, but to stitch a panorama, we must find the exact same points across two different views. By matching these descriptors, we create the critical links needed to eventually align and stitch images.

In this lesson, we will build a reliable feature matcher using OpenCV. We will configure our matcher based on descriptor data type and use Lowe's Ratio Test, a powerful technique for filtering out ambiguous matches.

Different algorithms produce different descriptor formats. SIFT produces arrays of floating-point numbers. ORB and AKAZE produce compact binary descriptors, represented as 8-bit unsigned integers.

Because our pipeline supports all three methods, our matcher needs to inspect the descriptor type before choosing a matching strategy.

import numpy as np

def descriptors_are_binary(descriptors):
    return descriptors is not None and descriptors.dtype == np.uint8

If the descriptor dtype is np.uint8, we treat it as binary. Otherwise, we treat it as a floating-point descriptor such as SIFT.

When matching descriptors, the algorithm computes distances between numeric fingerprints. A shorter distance means two descriptors look more similar.

For each descriptor in the first image, we ask for the two nearest candidates in the second image. The best candidate should be clearly better than the runner-up. If the two candidates are too close in quality, the match is ambiguous and should be rejected.

Descriptor from image A
        |
        |-- best candidate in image B      distance = 30
        |
        |-- second-best candidate in B     distance = 80

Ratio check:
best distance < ratio * second-best distance

With ratio = 0.75:
30 < 0.75 * 80
30 < 60  -> keep the match

Now compare that with an ambiguous case:

Descriptor from image A
        |
        |-- best candidate in image B      distance = 55
        |
        |-- second-best candidate in B     distance = 60

With ratio = 0.75:
55 < 0.75 * 60
55 < 45  -> reject the match

The ratio acts like a strictness dial:

• Lower values, such as 0.65, are stricter and produce fewer matches.
• Higher values, such as 0.85, are looser and may keep more false matches.

The core filtering loop is short:

good = []
for pair in raw_matches:
    if len(pair) == 2:
        best, second = pair
        if best.distance < ratio * second.distance:
            good.append(best)