Edge detection (Sobel, Laplacian) in Signal Processing - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Sobel filter on a simple 3x3 image

What is the output array after applying the Sobel filter in the x-direction on the following 3x3 grayscale image?

[[10, 10, 10],
 [20, 20, 20],
 [30, 30, 30]]

Signal Processing

import numpy as np
from scipy.ndimage import sobel

image = np.array([[10, 10, 10],
                  [20, 20, 20],
                  [30, 30, 30]])

sobel_x = sobel(image, axis=1, mode='constant')
print(sobel_x)

A

[[ 0  0  0]
 [ 0  0  0]
 [ 0  0  0]]

B

[[ 0  0  0]
 [10  0 -10]
 [10  0 -10]]

C

[[ 0  0  0]
 [ 0  0  0]
 [10  0 -10]]

D

[[ 0  0  0]
 [10  0 -10]
 [ 0  0  0]]

💡 Hint

Sobel in x-direction (axis=1) detects vertical edges by looking at changes horizontally along rows. Each row is constant, so zero output.

The Sobel filter in x-direction calculates differences between neighboring columns. Since all columns are identical, there are no horizontal changes, resulting in zero everywhere.

❓ data_output

intermediate

Number of edges detected by Laplacian filter

Given a 5x5 image with a single white square in the center on a black background, how many non-zero pixels does the Laplacian filter detect as edges?

Signal Processing

import numpy as np
from scipy.ndimage import laplace

image = np.zeros((5,5))
image[2,2] = 255
lap = laplace(image)
non_zero_count = np.count_nonzero(lap)
print(non_zero_count)

A 5

B 1

C 8

D 0

💡 Hint

Laplacian highlights pixels where intensity changes sharply, including neighbors of the white pixel.

The Laplacian filter detects edges by highlighting pixels where intensity changes. The single white pixel causes its four direct neighbors and itself to have non-zero Laplacian values, resulting in 5 non-zero pixels.

🔧 Debug

advanced

Identify the error in Sobel edge detection code

What error will this code raise when applying Sobel filter to an image?

import numpy as np
from scipy.ndimage import sobel

image = np.array([[1,2],[3,4]])
sobel_x = sobel(image, axis=2)

Signal Processing

import numpy as np
from scipy.ndimage import sobel

image = np.array([[1,2],[3,4]])
sobel_x = sobel(image, axis=2)

A No error, code runs successfully

B TypeError: unsupported operand type(s) for sobel

C ValueError: image must be 3D

D IndexError: axis 2 is out of bounds for array of dimension 2

💡 Hint

Check the axis parameter against the image array dimensions.

The image is 2D, so valid axis values are 0 or 1. Using axis=2 causes an IndexError because axis 2 does not exist.

❓ visualization

advanced

Visual difference between Sobel and Laplacian edges

Which option best describes the visual difference between Sobel and Laplacian edge detection results on a grayscale image?

A Sobel produces blurred edges, Laplacian produces sharp edges with color

B Sobel highlights edges with direction (horizontal or vertical), Laplacian highlights edges without direction

C Sobel detects edges only in color images, Laplacian only in grayscale

D Sobel and Laplacian produce identical edge maps

💡 Hint

Think about how Sobel uses gradients and Laplacian uses second derivatives.

Sobel filter calculates gradient in specific directions, so edges have orientation. Laplacian uses second derivative and highlights edges regardless of direction.

🚀 Application

expert

Choosing edge detection method for noisy images

You have a noisy grayscale image and want to detect edges robustly. Which method is best to reduce noise impact while detecting edges?

A Apply Laplacian filter directly without smoothing

B Use raw Sobel filter without any preprocessing

C Use Laplacian of Gaussian (LoG) filter combining smoothing and edge detection

D Apply Gaussian blur before Sobel filter to smooth noise

💡 Hint

Consider combining smoothing and edge detection in one step.

Laplacian of Gaussian first smooths the image to reduce noise, then applies Laplacian to detect edges, making it robust for noisy images.

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