In the first unit of this course, we outlined the image stitching pipeline and learned that to stitch images together, we must first find unique "landmarks" across our images.

Imagine trying to stitch together two pictures of a perfectly blank, blue sky. It would be nearly impossible because there are no unique reference points to tell you how the images align. However, if the images contain a highly textured brick building, the sharp edges and corners make alignment much easier.

In this second unit out of our five-unit journey, we will explore the Harris Corner Detector. The Harris algorithm is a "detector-only" method. It does not describe or match features across images; instead, it is a fantastic diagnostic tool. It shows us exactly where an algorithm finds corner-like structures. By building this tool, you will develop a strong intuition for why certain images are great for stitching, while others are prone to failure.

Before we can look for corners, we need to load and prepare our image. As a quick reminder from our previous discussions, we will use our custom cvkit helper library to read our image file and prepare it.

import cv2
import numpy as np
from cvkit import preprocess_for_features, read_color

image = read_color("sample_image.jpg")
gray = preprocess_for_features(image)

In this snippet, read_color safely loads our image. We then pass it to preprocess_for_features, which converts the image to grayscale. Corner detection relies on measuring drastic changes in light intensity (light to dark), so color information is not necessary and would only slow down our math.

Next, OpenCV's mathematical functions for finding corners require our grayscale image data to be in a specific format called a 32-bit float. We can convert our grayscale image using NumPy:

gray_float = np.float32(gray)

Now, our image is perfectly prepared for the Harris Corner Detector.

To find corners, we will use the cv2.cornerHarris() function provided by OpenCV. This function scans the image to find areas where the pixel intensity changes significantly in all directions — the classic definition of a corner.

response = cv2.cornerHarris(gray_float, blockSize=2, ksize=5, k=0.07)

Let us break down the parameters we just passed into the function:

• gray_float: This is our prepared, 32-bit float grayscale image.
• blockSize: This determines the size of the neighborhood the algorithm looks at. A value of 2 means it looks at a 2x2 pixel grid to detect corners.
• ksize: This is the aperture parameter used to mathematically find the edges. A value of 5 is a standard starting point.
• k: This is a mathematical parameter used to calculate the final "corner score." A standard value is 0.07.

The response we get back is not an image we can display. Instead, it is a map of scores. Every pixel gets a score indicating how "corner-like" it is.

Because the highest-scoring points in our response map are often just a single pixel wide, they can be very hard to see. We can use OpenCV's cv2.dilate() function to slightly enlarge these bright spots.

response = cv2.dilate(response, None)

Next, we want to isolate only the best, strongest corners. We can do this by setting a threshold. We will create a mask that only selects pixels where the score is greater than 1% (0.01) of the highest score found in the entire image.

mask = response > 0.01 * response.max()

Now that we know exactly where our strongest corners are, let us highlight them on a copy of our original color image. We will color these pixels bright red so they stand out. Keep in mind that OpenCV uses BGR (Blue, Green, Red) color ordering, so red is represented as [0, 0, 255].

output = image.copy()
output[mask] = [0, 0, 255]

We can wrap all of this logic into a clean, reusable function that returns both the highlighted image and the total number of corners it found.

def harris_overlay(image, gray):
    response = cv2.cornerHarris(np.float32(gray), blockSize=2, ksize=5, k=0.07)
    response = cv2.dilate(response, None)

    if response.max() <= 0:
        return image.copy(), 0

    mask = response > 0.01 * response.max()
    output = image.copy()
    output[mask] = [0, 0, 255]
    
    return output, int(mask.sum())

Now, we can integrate our overlay function into a main script. This script loads the image, processes it, prints helpful diagnostic counts to the terminal, and displays the results side-by-side using our cvkit.make_panel helper function.

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("path")
    parser.add_argument("--preview-size", type=int, default=900)
    args = parser.parse_args()

    image = read_color(args.path)
    gray = preprocess_for_features(image)

    corners, count = harris_overlay(image, gray)
    
    print("corner-like pixels:", count)
    print("note: this is a texture diagnostic, not the final matching method")

    cv2.imshow(
        "harris",
        make_panel(
            [
                ("feature input", gray),
                ("harris corner structure", corners),
            ],
            max_size=args.preview_size,
        ),
    )
    cv2.waitKey(0)
    cv2.destroyAllWindows()

If you run this code on an image of a textured building, you may see output in your terminal similar to this:

corner-like pixels: 4521
note: this is a texture diagnostic, not the final matching method

A window will also pop up, showing the grayscale image on the left and the original image covered with red corner highlights on the right.

In this lesson, you built a powerful diagnostic tool from scratch. You learned how to prepare an image, apply the Harris Corner Detector, enlarge the mathematical responses, and filter them using a threshold to create a visual overlay. By seeing where an image holds the most texture, you now have a foundational intuition for what makes an image suitable for panorama stitching.

Remember, the Harris algorithm is just a detector. It shows us the structure, but it cannot map points from one image to another.

In the interactive practice exercises coming up next, you will have the opportunity to write this code yourself. You will practice preparing the image arrays, tuning the cv2.cornerHarris() parameters, and applying the color masks to solidify these concepts before we move on to actual feature matching in the next unit.