Morphological operations (erosion, dilation) in SciPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of erosion on a binary image

What is the output array after applying erosion with a 3x3 square structuring element on the given binary image?

SciPy

import numpy as np
from scipy.ndimage import binary_erosion

image = np.array([
  [0, 0, 0, 0, 0],
  [0, 1, 1, 1, 0],
  [0, 1, 1, 1, 0],
  [0, 1, 1, 1, 0],
  [0, 0, 0, 0, 0]
], dtype=bool)

structure = np.ones((3,3), dtype=bool)
eroded = binary_erosion(image, structure=structure)
print(eroded.astype(int))

A

[[0 0 0 0 0]
 [0 1 1 1 0]
 [0 1 1 1 0]
 [0 1 1 1 0]
 [0 0 0 0 0]]

B

[[0 0 0 0 0]
 [0 0 1 0 0]
 [0 1 1 1 0]
 [0 0 1 0 0]
 [0 0 0 0 0]]

C

[[0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 1 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]]

D

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

💡 Hint

Erosion shrinks the white regions by removing pixels on the edges.

Erosion with a 3x3 structuring element removes pixels on the border of the white square, leaving only the center pixel as 1.

❓ Predict Output

intermediate

Result of dilation on a sparse binary image

What is the output after applying dilation with a 3x3 cross-shaped structuring element on the binary image below?

SciPy

import numpy as np
from scipy.ndimage import binary_dilation

image = np.array([
  [0, 0, 0, 0, 0],
  [0, 0, 1, 0, 0],
  [0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0]
], dtype=bool)

structure = np.array([
  [0, 1, 0],
  [1, 1, 1],
  [0, 1, 0]
], dtype=bool)
dilated = binary_dilation(image, structure=structure)
print(dilated.astype(int))

A

[[0 0 1 0 0]
 [0 1 1 1 0]
 [0 0 1 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]]

B

[[0 0 0 0 0]
 [0 1 1 1 0]
 [0 1 1 1 0]
 [0 0 1 0 0]
 [0 0 0 0 0]]

C

[[0 0 0 0 0]
 [0 1 1 1 0]
 [0 1 1 1 0]
 [0 1 0 1 0]
 [0 0 0 0 0]]

D

[[0 0 0 0 0]
 [0 0 1 0 0]
 [0 1 1 1 0]
 [0 0 1 0 0]
 [0 0 0 0 0]]

💡 Hint

Dilation adds pixels around existing white pixels according to the structuring element shape.

The cross-shaped structuring element dilates the single pixel to its immediate neighbors in a cross shape.

❓ visualization

advanced

Visualize erosion and dilation effects

Which option shows the correct pair of images after applying erosion and dilation respectively on the given binary image with a 3x3 square structuring element?

SciPy

import numpy as np
from scipy.ndimage import binary_erosion, binary_dilation
import matplotlib.pyplot as plt

image = np.array([
  [0, 0, 0, 0, 0],
  [0, 1, 1, 1, 0],
  [0, 1, 1, 1, 0],
  [0, 1, 1, 1, 0],
  [0, 0, 0, 0, 0]
], dtype=bool)

structure = np.ones((3,3), dtype=bool)
eroded = binary_erosion(image, structure=structure)
dilated = binary_dilation(image, structure=structure)

fig, axs = plt.subplots(1, 2)
axs[0].imshow(eroded, cmap='gray')
axs[0].set_title('Erosion')
axs[1].imshow(dilated, cmap='gray')
axs[1].set_title('Dilation')
plt.show()

A Left image: 3x3 white square with holes; Right image: 5x5 white square with holes

B Left image: 3x3 white square; Right image: 3x3 white square

C Left image: 5x5 white square; Right image: single pixel in center

D Left image: single pixel in center; Right image: 5x5 white square

💡 Hint

Erosion shrinks white areas, dilation expands them.

Erosion reduces the 3x3 white square to a single pixel, dilation expands it to fill the entire 5x5 area.

🧠 Conceptual

advanced

Effect of structuring element shape on dilation

Which statement correctly describes how the shape of the structuring element affects the dilation result on a binary image?

A The dilation result shape matches the structuring element shape centered on each white pixel.

B A larger structuring element always produces a smaller dilated area.

C The structuring element shape does not affect dilation, only erosion.

D Dilation removes pixels from the edges of white regions based on the structuring element.

💡 Hint

Think about how dilation adds pixels around existing ones.

Dilation adds pixels in the shape of the structuring element around each white pixel, so the output shape depends on the structuring element shape.

🔧 Debug

expert

Identify the error in morphological operation code

What error will occur when running the following code snippet for erosion, and why?

SciPy

import numpy as np
from scipy.ndimage import binary_erosion

image = np.array([
  [1, 1, 1],
  [1, 0, 1],
  [1, 1, 1]
])

structure = np.array([
  [1, 1],
  [1, 1]
])
eroded = binary_erosion(image, structure=structure)
print(eroded)

A ValueError because structuring element is not square

B TypeError because image array is not boolean

C No error, code runs and outputs eroded image

D IndexError due to structuring element size larger than image

💡 Hint

Check the data type required by binary_erosion for the input image.

binary_erosion expects a boolean array for the image. Using integers without converting to boolean causes a TypeError.

Practice

1. What does the erosion operation do to a binary image in morphological processing?

easy

A. It inverts the colors of the image.

B. It enlarges the white regions by adding pixels to edges.

C. It shrinks the white regions by removing edge pixels.

D. It blurs the image to reduce noise.

Solution

1. Step 1: Understand erosion effect

   Erosion removes pixels on object boundaries, making white regions smaller.

2. Step 2: Compare with other operations

   Dilation adds pixels, inversion changes colors, blurring smooths image; none match erosion.

3. Final Answer:

   It shrinks the white regions by removing edge pixels. -> Option C

4. Quick Check:

   Erosion = Shrink white regions [OK]

Hint: Erosion shrinks shapes by cutting edges [OK]

Common Mistakes:

• Confusing erosion with dilation
• Thinking erosion adds pixels
• Mixing erosion with color inversion

2. Which of the following is the correct way to import the erosion function from scipy's ndimage module?

easy

A. from scipy.ndimage import erosion

B. from scipy.ndimage import binary_erosion

C. import scipy.ndimage.erosion

D. from scipy import erosion

Solution

1. Step 1: Identify correct function name

   The function for erosion on binary images is named binary_erosion in scipy.ndimage.

2. Step 2: Check import syntax

   Correct import is from scipy.ndimage import binary_erosion. Other options are invalid or incorrect names.

3. Final Answer:

   from scipy.ndimage import binary_erosion -> Option B

4. Quick Check:

   Correct import = binary_erosion [OK]

Hint: Use binary_erosion for erosion in scipy.ndimage [OK]

Common Mistakes:

• Using wrong function name 'erosion'
• Incorrect import syntax
• Trying to import from scipy root

3. Given the following code, what will be the output array after applying dilation?

import numpy as np
from scipy.ndimage import binary_dilation

image = np.array([[0, 0, 0, 0, 0],
                  [0, 1, 1, 0, 0],
                  [0, 1, 0, 0, 0],
                  [0, 0, 0, 0, 0]])

result = binary_dilation(image).astype(int)
print(result)

medium

A. [[0 0 0 0 0]
[0 0 1 0 0]
[0 1 0 0 0]
[0 0 0 0 0]]

B. [[0 0 0 0 0]
[0 1 1 0 0]
[0 1 0 0 0]
[0 0 0 0 0]]

C. [[1 1 1 0 0]
[1 1 1 1 0]
[1 1 1 1 0]
[0 1 1 0 0]]

D. [[0 1 1 0 0]
[1 1 1 1 0]
[1 1 1 0 0]
[0 1 0 0 0]]

Solution

1. Step 1: Understand binary_dilation effect

   Dilation adds pixels to the edges of white regions (1s), expanding them by one pixel in all directions.

2. Step 2: Apply dilation to given image

   Original white pixels at (1,1),(1,2),(2,1). After dilation, neighbors become 1, resulting in the array in [[0 1 1 0 0] [1 1 1 1 0] [1 1 1 0 0] [0 1 0 0 0]].

3. Final Answer:

   [[0 1 1 0 0] [1 1 1 1 0] [1 1 1 0 0] [0 1 0 0 0]] -> Option D

4. Quick Check:

   Dilation = expand edges [OK]

Hint: Dilation grows white pixels by one layer [OK]

Common Mistakes:

• Confusing dilation with erosion
• Not converting boolean to int for print
• Misreading array indices

4. The following code is intended to perform erosion on a binary image, but it raises an error. What is the problem?

import numpy as np
from scipy.ndimage import erosion

image = np.array([[1, 1, 0],
                  [1, 0, 0],
                  [0, 0, 1]])

result = erosion(image)
print(result)

medium

A. The function 'erosion' does not exist in scipy.ndimage; use 'binary_erosion' instead.

B. The input image must be float type, not int.

C. The image array shape is invalid for erosion.

D. The print statement syntax is incorrect.

Solution

1. Step 1: Check function availability

   Scipy.ndimage does not have a function named 'erosion'; the correct function is 'binary_erosion'.

2. Step 2: Correct the import and usage

   Replace 'from scipy.ndimage import erosion' with 'from scipy.ndimage import binary_erosion' and call 'binary_erosion(image)'.

3. Final Answer:

   The function 'erosion' does not exist in scipy.ndimage; use 'binary_erosion' instead. -> Option A

4. Quick Check:

   Use binary_erosion, not erosion [OK]

Hint: Use binary_erosion, not erosion function [OK]

Common Mistakes:

• Trying to import non-existent 'erosion'
• Ignoring error messages
• Assuming all morphological functions have simple names

5. You have a noisy binary image with small white dots scattered outside the main object. Which sequence of morphological operations using scipy.ndimage would best remove these small dots but keep the main shape mostly intact?

hard

A. Apply erosion followed by dilation (opening) to remove small objects.

B. Apply dilation followed by erosion (closing) to fill small holes.

C. Apply only dilation to enlarge all white areas.

D. Apply only erosion to shrink all white areas drastically.

Solution

1. Step 1: Understand noise removal goal

   Small white dots are noise; we want to remove them without changing main shape much.

2. Step 2: Choose correct morphological sequence

   Opening (erosion then dilation) removes small objects but keeps main shape. Closing fills holes, not remove dots.

3. Final Answer:

   Apply erosion followed by dilation (opening) to remove small objects. -> Option A

4. Quick Check:

   Opening = erosion + dilation removes noise [OK]

Hint: Use opening (erosion then dilation) to remove small noise [OK]

Common Mistakes:

• Using closing instead of opening for noise removal
• Applying only dilation or erosion alone
• Confusing noise removal with hole filling