Edge detection (Sobel, Laplacian) in Signal Processing - Mini Project: Build & Apply

Edge Detection with Sobel and Laplacian Filters

📖 Scenario: You work as a data scientist helping a company analyze images to find edges. Edges help highlight important shapes and details in pictures, like outlines of objects.We will use simple image data and apply two common edge detection filters: Sobel and Laplacian. These filters help find where the image changes sharply, showing edges.

🎯 Goal: Build a small program that loads a simple image as a 2D list, sets a filter type, applies the chosen edge detection filter (Sobel or Laplacian), and prints the resulting edge-detected image.

📋 What You'll Learn

Create a 2D list called image with exact pixel values

Create a variable called filter_type with value 'sobel' or 'laplacian'

Write code to apply the chosen filter to the image

Print the resulting edge-detected image as a 2D list

💡 Why This Matters

🌍 Real World

Edge detection is used in photo editing, medical imaging, and computer vision to find important shapes and boundaries in images.

💼 Career

Understanding edge detection helps in roles like data scientist, computer vision engineer, and image processing specialist.

1

Create the image data

Create a 5x5 2D list called image with these exact values: [[10, 10, 10, 10, 10], [10, 50, 50, 50, 10], [10, 50, 100, 50, 10], [10, 50, 50, 50, 10], [10, 10, 10, 10, 10]]

Signal Processing

# Create the 5x5 image data as a 2D list called image
# Your code here

Hint

Use square brackets to create a list of lists. Each inner list is a row of pixels.

2

Set the filter type

Create a variable called filter_type and set it to the string 'sobel'

Signal Processing

image = [
    [10, 10, 10, 10, 10],
    [10, 50, 50, 50, 10],
    [10, 50, 100, 50, 10],
    [10, 50, 50, 50, 10],
    [10, 10, 10, 10, 10]
]
# Set the filter_type variable to 'sobel'
# Your code here

Hint

Use an equals sign to assign the string 'sobel' to the variable filter_type.

3

Apply the chosen edge detection filter

Write code to apply the chosen filter to the image. Use these exact variable names and logic:
- Create an empty 5x5 2D list called edges filled with zeros
- If filter_type is 'sobel', apply the Sobel filter in the x direction:
    Sobel kernel: [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]
- If filter_type is 'laplacian', apply the Laplacian filter:
    Laplacian kernel: [[0, 1, 0], [1, -4, 1], [0, 1, 0]]
- Use nested for loops with variables i and j to iterate over the image pixels excluding the border (1 to 3)
- Calculate the convolution sum for each pixel and store it in edges[i][j]

Signal Processing

image = [
    [10, 10, 10, 10, 10],
    [10, 50, 50, 50, 10],
    [10, 50, 100, 50, 10],
    [10, 50, 50, 50, 10],
    [10, 10, 10, 10, 10]
]
filter_type = 'sobel'

# Create edges list and apply filter
# Your code here

Hint

Use nested loops to slide the 3x3 kernel over the image pixels except the border. Multiply and sum the kernel values with the image pixels.

4

Print the edge detected image

Write a print statement to display the edges 2D list

Signal Processing

image = [
    [10, 10, 10, 10, 10],
    [10, 50, 50, 50, 10],
    [10, 50, 100, 50, 10],
    [10, 50, 50, 50, 10],
    [10, 10, 10, 10, 10]
]
filter_type = 'sobel'

edges = [[0 for _ in range(5)] for _ in range(5)]

if filter_type == 'sobel':
    kernel = [[-1, 0, 1],
              [-2, 0, 2],
              [-1, 0, 1]]
elif filter_type == 'laplacian':
    kernel = [[0, 1, 0],
              [1, -4, 1],
              [0, 1, 0]]

for i in range(1, 4):
    for j in range(1, 4):
        conv_sum = 0
        for ki in range(3):
            for kj in range(3):
                conv_sum += kernel[ki][kj] * image[i + ki - 1][j + kj - 1]
        edges[i][j] = conv_sum

# Print the edges list
# Your code here

Hint

Use print(edges) to show the final edge detected image.

Practice

1. What is the main purpose of the Sobel operator in edge detection?

easy

A. To detect color changes in an image

B. To smooth the image by averaging pixel values

C. To find edges by calculating gradients in horizontal and vertical directions

D. To reduce noise using a median filter

Solution

1. Step 1: Understand Sobel operator function

   The Sobel operator calculates the gradient of image intensity in horizontal and vertical directions.

2. Step 2: Identify purpose in edge detection

   Gradients highlight sharp changes in intensity, which correspond to edges.

3. Final Answer:

   To find edges by calculating gradients in horizontal and vertical directions -> Option C

4. Quick Check:

   Sobel = gradient edge detection [OK]

Hint: Sobel finds edges by gradients horizontally and vertically [OK]

Common Mistakes:

• Confusing Sobel with smoothing filters
• Thinking Sobel detects color changes
• Mixing Sobel with noise reduction methods

2. Which of the following is the correct 3x3 Sobel kernel for detecting vertical edges?

easy

A. [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]

B. [[1, 2, 1], [0, 0, 0], [-1, -2, -1]]

C. [[0, 1, 0], [1, -4, 1], [0, 1, 0]]

D. [[1, 0, -1], [2, 0, -2], [1, 0, -1]]

Solution

1. Step 1: Recall Sobel vertical kernel

   The Sobel vertical kernel detects edges by emphasizing horizontal intensity changes and is defined as [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]].

2. Step 2: Compare options

   [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]] matches the known vertical Sobel kernel; others are horizontal or Laplacian kernels.

3. Final Answer:

   [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]] -> Option A

4. Quick Check:

   Vertical Sobel kernel = [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]] [OK]

Hint: Vertical Sobel kernel has -1 and 1 on sides, 0 in middle column [OK]

Common Mistakes:

• Confusing vertical and horizontal Sobel kernels
• Selecting Laplacian kernel instead
• Mixing signs in kernel values

3. Given the following 3x3 image patch:
[[10, 10, 10], [10, 0, 10], [10, 10, 10]]
What is the approximate output of applying the Laplacian kernel [[0, 1, 0], [1, -4, 1], [0, 1, 0]] at the center pixel?

medium

A. -40

B. 0

C. -10

D. 40

Solution

1. Step 1: Overlay kernel on image patch

   Center pixel [1,1]=0. Relevant positions: top-center [0,1]=10, mid-left [1,0]=10, mid-right [1,2]=10, bottom-center [2,1]=10. Others have kernel weight 0.

2. Step 2: Compute weighted sum

   (1*10) + (1*10) + (-4*0) + (1*10) + (1*10) = 10 + 10 + 0 + 10 + 10 = 40.

3. Final Answer:

   40 -> Option D

4. Quick Check:

   Laplacian = sum(neighbors) - 4*center = 40 - 0 = 40 [OK]

Hint: Sum neighbors times 1 minus 4 times center pixel [OK]

Common Mistakes:

• Ignoring kernel sign and weights
• Mixing neighbor and center pixel values
• Calculating sum incorrectly

4. Consider this Python code snippet applying Sobel filter:

import numpy as np
image = np.array([[1,2,1],[0,1,0],[2,1,2]])
sobel_x = np.array([[1,0,-1],[2,0,-2],[1,0,-1]])
result = np.zeros_like(image)
for i in range(1,2):
    for j in range(1,2):
        region = image[i-1:i+2, j-1:j+2]
        result[i,j] = np.sum(region * sobel_x)
print(result[1,1])

What is the output and is there any error?

medium

A. Output is 0; error due to incorrect loop range

B. Output is 0; no error

C. Output is 2; no error

D. Output is 2; error due to incorrect loop range

Solution

1. Step 1: Analyze loop ranges and region extraction

   Loops run for i=1 and j=1 only, extracting 3x3 region around center pixel (1,1).

2. Step 2: Calculate convolution sum

   Region = [[1,2,1],[0,1,0],[2,1,2]]
   sobel_x = [[1,0,-1],[2,0,-2],[1,0,-1]]
   Element-wise multiply and sum:
   (1*1)+(2*0)+(1*-1)+(0*2)+(1*0)+(0*-2)+(2*1)+(1*0)+(2*-1) = 1+0-1+0+0+0+2+0-2 = 0

3. Step 3: Check for errors

   Loop ranges are correct for this small image to avoid index errors.
   No error occurs.

4. Final Answer:

   0; no error -> Option B

5. Quick Check:

   Convolution sum = 0; loops correct [OK]

Hint: Check loop ranges match image size to avoid errors [OK]

Common Mistakes:

• Using wrong loop ranges causing index errors
• Miscomputing convolution sum
• Assuming output is non-zero without calculation

5. You want to detect edges in a noisy grayscale image. Which approach best improves edge detection results using Sobel and Laplacian filters?

hard

A. Apply Gaussian smoothing before Sobel, then use Laplacian on result

B. Apply Laplacian first, then Sobel without smoothing

C. Use Sobel only without any smoothing

D. Apply median filter after Laplacian to sharpen edges

Solution

1. Step 1: Understand noise effect on edge detection

   Noisy images cause false edges; smoothing reduces noise before edge detection.

2. Step 2: Combine smoothing and edge detection

   Applying Gaussian smoothing before Sobel reduces noise impact.
   Then applying Laplacian on Sobel result enhances edge detection.

3. Step 3: Evaluate other options

   Applying Laplacian first without smoothing amplifies noise.
   Using Sobel only misses benefits of combined filters.
   Median filter after Laplacian may remove edges, not sharpen.

4. Final Answer:

   Apply Gaussian smoothing before Sobel, then use Laplacian on result -> Option A

5. Quick Check:

   Smoothing before edge detection improves results [OK]

Hint: Smooth noisy image before edge detection [OK]

Common Mistakes:

• Skipping smoothing step on noisy images
• Applying filters in wrong order
• Assuming median filter sharpens edges