Image filtering (gaussian_filter) in SciPy - Step-by-Step Execution

Concept Flow - Image filtering (gaussian_filter)

Input Image Array

↓

Apply gaussian_filter

↓

Smooth Image Output

↓

Use or Display Result

Start with an image array, apply gaussian_filter to smooth it, then get the filtered image for use or display.

Execution Sample

SciPy

import numpy as np
from scipy.ndimage import gaussian_filter

image = np.array([[10, 10, 10],
                  [10, 50, 10],
                  [10, 10, 10]])
filtered = gaussian_filter(image, sigma=1)

This code smooths a small 3x3 image using a Gaussian filter with sigma=1.

Execution Table

Step	Action	Input Value	Filter Parameter	Output Value
1	Input image created	[[10,10,10],[10,50,10],[10,10,10]]	sigma=1	Same as input
2	Apply gaussian_filter	Image array	sigma=1	Smoothed image array
3	Calculate weighted average for center pixel	Center=50 neighbors=10	sigma=1	Center pixel approx 22.5
4	Calculate weighted average for corner pixel	Corner=10 neighbors=10 and 50	sigma=1	Corner pixel approx 12.5
5	Filtered image ready	N/A	N/A	[[12.5, 15.6, 12.5],[15.6, 22.5, 15.6],[12.5, 15.6, 12.5]]

💡 Filtering complete, output is smoothed image array

Variable Tracker

Variable	Start	After gaussian_filter	Final
image	[[10,10,10],[10,50,10],[10,10,10]]	[[10,10,10],[10,50,10],[10,10,10]]	Same as start
filtered	None	N/A	[[12.5, 15.6, 12.5],[15.6, 22.5, 15.6],[12.5, 15.6, 12.5]]

Key Moments - 2 Insights

Why does the center pixel value decrease after filtering?

Because gaussian_filter smooths by averaging neighbors weighted by distance, the high center value (50) blends with lower neighbors (10), lowering it to about 22.5 (see execution_table step 3).

Why do corner pixels increase after filtering?

Corner pixels start at 10 but neighbors include the higher center pixel 50, so weighted averaging raises their value to about 12.5 (see execution_table step 4).

Visual Quiz - 3 Questions

Look at the execution table, what is the approximate filtered value of the center pixel?

A 22.5

B 10

C 50

D 15.6

💡 Hint

Check execution_table row 3 where the center pixel calculation is shown.

At which step does the gaussian_filter produce the smoothed image array?

A Step 1

B Step 2

C Step 5

D Step 3

💡 Hint

Check execution_table row 2 where gaussian_filter is applied.

If sigma was increased, how would the filtered image values change?

A No change in values

B Less smoothing, values closer to original

C More smoothing, values more blended

D Filtered image becomes sharper

💡 Hint

Gaussian sigma controls smoothing strength; higher sigma means more blending.

Concept Snapshot

gaussian_filter(image, sigma)
- Smooths image by weighted averaging neighbors
- sigma controls blur amount (higher = more blur)
- Output is same shape, float values
- Useful to reduce noise or details
- Works on numpy arrays representing images

Full Transcript

We start with a small 3x3 image array with a bright center pixel. Applying gaussian_filter with sigma=1 smooths the image by averaging each pixel with neighbors weighted by distance. The center pixel value decreases because it blends with lower neighbors, while corner pixels increase slightly due to influence from the bright center. The final filtered image is a smoothed version with less sharp contrast. Increasing sigma would increase smoothing. This process helps reduce noise or details in images.

Practice

1. What is the main purpose of using gaussian_filter in image processing?

easy

A. To detect edges in the image

B. To smooth the image by reducing noise

C. To convert the image to grayscale

D. To increase the image resolution

Solution

1. Step 1: Understand the function's role

   gaussian_filter applies a blur effect that smooths the image by averaging nearby pixels weighted by a Gaussian curve.

2. Step 2: Identify the effect on image quality

   This smoothing reduces noise and small details, making the image less sharp but cleaner.

3. Final Answer:

   To smooth the image by reducing noise -> Option B

4. Quick Check:

   Gaussian blur = noise reduction [OK]

Hint: Gaussian filter smooths images by blurring noise away [OK]

Common Mistakes:

• Thinking it increases resolution
• Confusing it with edge detection
• Assuming it changes color format

2. Which of the following is the correct way to import and apply a Gaussian filter with sigma=2 to a 2D numpy array named image?

easy

A. from scipy.ndimage import gaussian_filter
filtered = gaussian_filter(image, sigma=2)

B. import scipy
filtered = scipy.gaussian_filter(image, 2)

C. from scipy import gaussian_filter
filtered = gaussian_filter(image, 2)

D. import gaussian_filter from scipy.ndimage
filtered = gaussian_filter(image, sigma=2)

Solution

1. Step 1: Check the correct import statement

   The Gaussian filter is in scipy.ndimage, so import it with from scipy.ndimage import gaussian_filter.

2. Step 2: Verify function usage

   Apply it by calling gaussian_filter(image, sigma=2) to blur with sigma 2.

3. Final Answer:

   from scipy.ndimage import gaussian_filter filtered = gaussian_filter(image, sigma=2) -> Option A

4. Quick Check:

   Correct import and sigma usage = from scipy.ndimage import gaussian_filter filtered = gaussian_filter(image, sigma=2) [OK]

Hint: Import from scipy.ndimage, use sigma as keyword [OK]

Common Mistakes:

• Wrong import path for gaussian_filter
• Passing sigma as positional without keyword
• Using incorrect import syntax

3. Given the code below, what will be the output array after applying the Gaussian filter?

import numpy as np
from scipy.ndimage import gaussian_filter

image = np.array([[0, 0, 0],
                  [0, 10, 0],
                  [0, 0, 0]])
filtered = gaussian_filter(image, sigma=1)
print(np.round(filtered, 2))

medium

A. [[0.46 1.23 0.46]
[1.23 2.99 1.23]
[0.46 1.23 0.46]]

B. [[0 0 0]
[0 10 0]
[0 0 0]]

C. [[2.5 2.5 2.5]
[2.5 2.5 2.5]
[2.5 2.5 2.5]]

D. [[0.1 0.1 0.1]
[0.1 10 0.1]
[0.1 0.1 0.1]]

Solution

1. Step 1: Understand Gaussian filter effect on sparse image

   The single bright pixel (10) will blur into neighbors, spreading intensity smoothly.

2. Step 2: Calculate approximate blurred values

   Using sigma=1, the center pixel reduces from 10 to about 3, neighbors get values around 1.2 to 0.46.

3. Final Answer:

   [[0.46 1.23 0.46] [1.23 2.99 1.23] [0.46 1.23 0.46]] -> Option A

4. Quick Check:

   Blur spreads intensity smoothly = [[0.46 1.23 0.46] [1.23 2.99 1.23] [0.46 1.23 0.46]] [OK]

Hint: Gaussian blur spreads bright pixels softly to neighbors [OK]

Common Mistakes:

• Expecting no change in array
• Assuming uniform average instead of weighted blur
• Misreading sigma effect as sharpening

4. Identify the error in the following code snippet that applies a Gaussian filter:

import numpy as np
from scipy.ndimage import gaussian_filter

image = np.ones((5,5))
filtered = gaussian_filter(image, sigma='2')
print(filtered)

medium

A. gaussian_filter cannot be applied to numpy arrays

B. The array shape is invalid for gaussian_filter

C. Missing import for numpy

D. sigma should be a number, not a string

Solution

1. Step 1: Check parameter types

   The sigma parameter must be a numeric value (int or float), not a string.

2. Step 2: Identify the cause of error

   Passing '2' as a string causes a type error when the filter tries to compute the blur.

3. Final Answer:

   sigma should be a number, not a string -> Option D

4. Quick Check:

   Numeric sigma required, string causes error [OK]

Hint: Use numeric sigma, not string, to avoid errors [OK]

Common Mistakes:

• Passing sigma as string
• Assuming gaussian_filter needs special array types
• Ignoring import errors

5. You have a noisy grayscale image stored as a 2D numpy array. You want to smooth the image but keep edges relatively sharp. Which approach using gaussian_filter and its parameters is best?

hard

A. Apply gaussian_filter multiple times with sigma=3

B. Use a large sigma value like 5 to blur the image heavily

C. Use a small sigma value like 0.5 to reduce noise but preserve edges

D. Do not use gaussian_filter; use median filter instead

Solution

1. Step 1: Understand sigma effect on smoothing

   Small sigma values cause light blur, preserving edges better than large sigma which blurs heavily.

2. Step 2: Choose best sigma for noise reduction and edge preservation

   Using sigma=0.5 smooths noise but keeps edges sharper than larger sigma values or repeated blurring.

3. Final Answer:

   Use a small sigma value like 0.5 to reduce noise but preserve edges -> Option C

4. Quick Check:

   Small sigma = smooth noise + keep edges [OK]

Hint: Small sigma blurs less, preserving edges better [OK]

Common Mistakes:

• Using large sigma blurs edges too much
• Applying filter multiple times causes over-blur
• Confusing gaussian_filter with median filter