Image sharpening in Signal Processing - Step-by-Step Execution

Concept Flow - Image sharpening

Input: Original Image

↓

Apply Sharpening Filter

↓

Enhance Edges & Details

↓

Output: Sharpened Image

Image sharpening enhances edges and details by applying a filter to the original image, producing a clearer output.

Execution Sample

Signal Processing

import cv2
import numpy as np

kernel = np.array([[0, -1, 0],
                   [-1, 5, -1],
                   [0, -1, 0]])
sharpened = cv2.filter2D(src=image, ddepth=-1, kernel=kernel)

This code applies a sharpening filter to an image using a convolution kernel.

Execution Table

Step	Pixel Position (x,y)	Original Pixel Value	Kernel Applied	New Pixel Value	Explanation
1	(1,1)	100	Center * 5	500	Center pixel multiplied by 5
2	(1,1)	Neighbors	Sum of neighbors * -1	-400	Sum of neighbors multiplied by -1
3	(1,1)	Calculate	500 + (-400)	100	Sum center and neighbors result
4	(1,1)	Clamp	Value within 0-255	100	Value clamped to valid pixel range
5	(1,2)	Repeat	Apply kernel similarly	Value updated	Process repeats for next pixel
...	...	...	...	...	...
N	All pixels processed	-	-	Sharpened image ready	All pixels updated with filter
Exit	-	-	-	-	All pixels processed, sharpening complete

💡 All pixels processed with the sharpening kernel, producing the sharpened image.

Variable Tracker

Variable	Start	After Pixel (1,1)	After Pixel (1,2)	...	Final
image	Original image matrix	Unchanged	Unchanged	...	Unchanged
kernel	[[0,-1,0],[-1,5,-1],[0,-1,0]]	Unchanged	Unchanged	...	Unchanged
sharpened	Empty matrix	Pixel (1,1) updated	Pixel (1,2) updated	...	Complete sharpened image

Key Moments - 3 Insights

Why do we multiply the center pixel by 5 and neighbors by -1?

The kernel is designed to emphasize the center pixel (multiply by 5) and subtract the neighbors (multiply by -1) to highlight edges, as shown in execution_table rows 1 and 2.

Why do we clamp pixel values after calculation?

Pixel values must stay between 0 and 255 to be valid colors. Clamping ensures values outside this range are adjusted, as seen in execution_table row 4.

Does the original image change during sharpening?

No, the original image remains unchanged. The sharpened image is stored separately, as tracked in variable_tracker.

Visual Quiz - 3 Questions

Look at the execution_table, what is the new pixel value at step 3 for pixel (1,1)?

A 500

B 100

C -400

D 0

💡 Hint

Check the 'New Pixel Value' column at step 3 in execution_table.

At which step do we ensure the pixel value is within the valid range?

A Step 1

B Step 2

C Step 4

D Step 5

💡 Hint

Look for the step mentioning 'Clamp' in the Explanation column of execution_table.

If the kernel center value changed from 5 to 3, how would the new pixel value at step 3 change?

A It would decrease

B It would stay the same

C It would increase

D It would become negative

💡 Hint

Refer to how the center pixel is multiplied in execution_table step 1 and summed in step 3.

Concept Snapshot

Image sharpening uses a filter kernel to enhance edges.
The center pixel is emphasized; neighbors are subtracted.
Apply convolution to each pixel.
Clamp results to 0-255 range.
Output is a sharper, clearer image.

Full Transcript

Image sharpening improves image clarity by emphasizing edges. We apply a filter kernel that multiplies the center pixel by 5 and subtracts neighbors by 1. Each pixel is processed by summing these weighted values. After calculation, pixel values are clamped between 0 and 255 to keep colors valid. The original image stays unchanged, and the sharpened image is stored separately. This process repeats for every pixel, resulting in a clearer, sharper image.

Practice

1. What is the main purpose of image sharpening in signal processing?

easy

A. To reduce the image size

B. To highlight edges and make the image clearer

C. To blur the image for artistic effect

D. To convert the image to grayscale

Solution

1. Step 1: Understand image sharpening

   Image sharpening enhances edges and details to make images clearer.

2. Step 2: Compare options

   Only To highlight edges and make the image clearer describes highlighting edges and clarity, which is the goal of sharpening.

3. Final Answer:

   To highlight edges and make the image clearer -> Option B

4. Quick Check:

   Image sharpening = highlight edges [OK]

Hint: Sharpening means making edges clearer, not blurring [OK]

Common Mistakes:

• Confusing sharpening with blurring
• Thinking sharpening changes image size
• Assuming sharpening converts color formats

2. Which of the following is the correct Python syntax to apply a simple sharpening kernel using convolution with OpenCV?

easy

A. cv2.sharpen(image, kernel)

B. cv2.convolve(image, kernel)

C. cv2.filter2D(image, -1, kernel)

D. cv2.applySharpen(image, kernel)

Solution

1. Step 1: Recall OpenCV function for convolution

   OpenCV uses cv2.filter2D() to apply kernels for filtering images.

2. Step 2: Check options

   Only cv2.filter2D(image, -1, kernel) uses cv2.filter2D with correct parameters; others are invalid functions.

3. Final Answer:

   cv2.filter2D(image, -1, kernel) -> Option C

4. Quick Check:

   OpenCV convolution = filter2D [OK]

Hint: Use cv2.filter2D for custom kernel convolution [OK]

Common Mistakes:

• Using non-existent OpenCV functions
• Confusing convolution with sharpening function names
• Incorrect parameter order

3. Given the following Python code using OpenCV, what will be the output type of sharpened?

import cv2
import numpy as np
image = cv2.imread('photo.jpg')
kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
sharpened = cv2.filter2D(image, -1, kernel)

medium

A. A sharpened image as a NumPy array

B. An error due to kernel shape

C. A grayscale image

D. A blurred image

Solution

1. Step 1: Understand filter2D output

   cv2.filter2D returns an image as a NumPy array after applying the kernel.

2. Step 2: Analyze kernel and output

   The kernel is a sharpening kernel, so output is sharpened image, still in color and array form.

3. Final Answer:

   A sharpened image as a NumPy array -> Option A

4. Quick Check:

   filter2D output = NumPy array image [OK]

Hint: filter2D returns image array, not blurred or grayscale [OK]

Common Mistakes:

• Assuming output is blurred instead of sharpened
• Thinking output is grayscale without conversion
• Believing kernel shape causes error

4. Identify the error in this Python code snippet for image sharpening:

import cv2
import numpy as np
image = cv2.imread('img.png')
kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
sharpened = cv2.filter2D(image, 1, kernel)
cv2.imshow('Sharpened', sharpened)
cv2.waitKey(0)
cv2.destroyAllWindows()

medium

A. The ddepth parameter should be -1, not 1

B. The kernel shape is invalid

C. cv2.imshow cannot display color images

D. cv2.waitKey is missing argument

Solution

1. Step 1: Check ddepth parameter in filter2D

   ddepth=-1 means output image has same depth as input; 1 is invalid and may cause errors.

2. Step 2: Validate other code parts

   Kernel shape is valid, cv2.imshow supports color, waitKey(0) is correct usage.

3. Final Answer:

   The ddepth parameter should be -1, not 1 -> Option A

4. Quick Check:

   ddepth=-1 for same depth [OK]

Hint: Use ddepth=-1 in filter2D to keep image depth [OK]

Common Mistakes:

• Using wrong ddepth value causing errors
• Thinking kernel shape is wrong
• Misunderstanding cv2.imshow capabilities

5. You want to sharpen an image using unsharp masking. Which sequence of steps correctly applies this method?

hard

A. Directly apply a sharpening kernel without blurring

B. Add noise to the image, then apply a sharpening kernel

C. Convert image to grayscale, then apply a sharpening kernel

D. Blur the image, subtract the blurred from original, then add result back to original

Solution

1. Step 1: Understand unsharp masking process

   Unsharp masking involves blurring the image, subtracting this blur from original to get edges, then adding edges back.

2. Step 2: Evaluate options

   Only Blur the image, subtract the blurred from original, then add result back to original correctly describes this sequence; others miss key steps or add unrelated actions.

3. Final Answer:

   Blur the image, subtract the blurred from original, then add result back to original -> Option D

4. Quick Check:

   Unsharp masking = blur, subtract, add [OK]

Hint: Unsharp masking = blur, subtract, add back edges [OK]

Common Mistakes:

• Skipping the blur step
• Adding noise instead of subtracting blur
• Applying sharpening kernel directly without unsharp steps