Okay, let's put the theory into practice. In the previous sections, we discussed the concept of edges as significant changes in intensity and learned about the Canny edge detector, a popular and effective algorithm for finding these edges. Now, we'll use the OpenCV library in Python to apply the Canny algorithm to an image.

Make sure you have your Python environment set up with OpenCV installed, as covered in Chapter 1. You'll also need Matplotlib to display the images easily. If you don't have Matplotlib installed, you can typically install it using pip:

pip install matplotlib

Loading an Image

First, we need an image to work on. Choose an image that has some reasonably clear objects or structures. Save it in your project directory. We'll start by importing the necessary libraries and loading the image. For edge detection, it's common practice to work with grayscale images, as color information isn't needed to find intensity changes. We can load the image directly as grayscale using cv2.imread().

import cv2
import matplotlib.pyplot as plt

# Load the image in grayscale
# Replace 'your_image.jpg' with the actual path to your image file
image_path = 'your_image.jpg'
gray_image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

# Check if the image was loaded successfully
if gray_image is None:
    print(f"Error: Could not load image from {image_path}")
    # Exit or handle the error appropriately
else:
    print("Image loaded successfully.")
    # You might want to display the original grayscale image here (optional)
    # plt.imshow(gray_image, cmap='gray')
    # plt.title('Original Grayscale Image')
    # plt.axis('off') # Hide axes ticks
    # plt.show()

Remember to replace 'your_image.jpg' with the filename of your chosen image. The cv2.IMREAD_GRAYSCALE flag tells OpenCV to convert the image to a single channel (grayscale) upon loading. We also added a check to ensure the image loaded correctly, which is good practice.

Applying the Canny Edge Detector

With the grayscale image loaded, applying the Canny edge detector in OpenCV is straightforward using the cv2.Canny() function. The main parameters we need to provide are:

image: The input grayscale image (like our gray_image).
threshold1: The lower threshold for the hysteresis procedure.
threshold2: The upper threshold for the hysteresis procedure.

As discussed conceptually earlier, the Canny algorithm uses these two thresholds. Edges with intensity gradients above threshold2 are considered definite edges. Edges below threshold1 are discarded. Edges between the two thresholds are only kept if they are connected to a definite edge.

Choosing these thresholds is often application-dependent and may require some experimentation. Let's start with some common values, like 100 and 200.

# Apply the Canny edge detector
# Using threshold1=100 and threshold2=200 as starting values
edges = cv2.Canny(gray_image, 100, 200)

# The 'edges' variable now holds the edge map image
# It's a binary image where white pixels represent detected edges

The output edges is a binary image (containing only black and white pixels) where white pixels indicate the locations of detected edges.

Displaying the Results

Now, let's display the original grayscale image and the resulting edge map side-by-side using Matplotlib to compare them.

import cv2
import matplotlib.pyplot as plt

# --- Load Image (as before) ---
image_path = 'your_image.jpg' # Make sure this path is correct
gray_image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

if gray_image is None:
    print(f"Error: Could not load image from {image_path}")
else:
    # --- Apply Canny (as before) ---
    threshold1 = 100
    threshold2 = 200
    edges = cv2.Canny(gray_image, threshold1, threshold2)

    # --- Display the results ---
    plt.figure(figsize=(10, 5)) # Set the figure size

    # Display original grayscale image
    plt.subplot(1, 2, 1) # 1 row, 2 columns, plot 1
    plt.imshow(gray_image, cmap='gray')
    plt.title('Original Grayscale Image')
    plt.axis('off') # Hide axis ticks and labels

    # Display Canny edge map
    plt.subplot(1, 2, 2) # 1 row, 2 columns, plot 2
    plt.imshow(edges, cmap='gray')
    plt.title(f'Canny Edges (T1={threshold1}, T2={threshold2})')
    plt.axis('off') # Hide axis ticks and labels

    plt.tight_layout() # Adjust layout to prevent overlap
    plt.show()

When you run this code, you should see two images: your original grayscale input and the Canny edge map. The edge map should highlight the outlines and significant intensity changes in your image.

Experimenting with Thresholds

The quality of the edge detection heavily depends on the threshold1 and threshold2 values.

Lowering thresholds (e.g., 50, 150): This will generally detect more edges, including weaker ones. However, it might also pick up more noise and less significant details, making the edge map look cluttered.
Increasing thresholds (e.g., 150, 250): This will result in fewer detected edges, keeping only the stronger ones. This can be useful for reducing noise but might cause you to lose finer edge details or parts of weaker object boundaries.

Try modifying the threshold1 and threshold2 values in the code and re-running it. Observe how the resulting edge map changes. Finding the "best" thresholds often involves trying a few values until you get a result that suits your specific goal for that image. There's no single perfect set of thresholds for all images.

This hands-on exercise demonstrates how to apply a fundamental feature detection technique. The resulting edge map simplifies the image, retaining important structural information while discarding irrelevant details. This edge information is a valuable input for many subsequent computer vision tasks.