Summary  
This chapter explains how to apply Gaussian and median filters to smooth data arrays and reduce noise by performing weighted averaging and median aggregation within local neighborhoods.

General domain of usage  
Image processing

Noise in images appears as unwanted graininess or distortion, often caused by low lighting, compression artifacts, or sensor limitations. Smoothing techniques help **reduce noise while preserving important image details**.


## Gaussian Blurring (Smoothing Noise)
`cv2.GaussianBlur` function applies a **Gaussian blur**, which smooths the image by averaging pixel values using a Gaussian kernel (a weighted average that gives more importance to central pixels):

- `cv2.GaussianBlur(src, ksize, sigmaX)`:  
  - `src`: the source image to be blurred;
  - `ksize`: kernel size in the format `(width, height)`, both values must be odd (e.g., `(5, 5)`);
  - `sigmaX`: standard deviation in the X direction; controls the amount of blur.  
- The function reduces image noise and detail by convolving the image with a Gaussian function, which is useful in tasks like edge detection or pre-processing before thresholding.

```
blurred = cv2.GaussianBlur(image, ksize, sigmaX)
```

In `cv2.GaussianBlur()`, parameter `sigmaX`, is the Gaussian kernel **standard deviation in the X direction**, and the same parameter in the Y direction (`sigmaY`) has the value **0 as default**. When both `sigmaX` and `sigmaY` have a value of 0, **the standard deviation is calculated from kernel size**.

Study More

## Median Blurring (Salt-and-Pepper Noise Removal)
`cv2.medianBlur` function applies a **median filter**, which replaces each pixel value with the median value of the neighboring pixels in the kernel window:

- `cv2.medianBlur(src, ksize)`:  
  - `src`: the source image to be filtered;
  - `ksize`: size of the square kernel (must be an odd integer, e.g., `3`, `5`, `7`).  
- The median blur is especially effective at removing **salt-and-pepper noise**, as it preserves edges while eliminating isolated noisy pixels.

```
median_blurred = cv2.medianBlur(image, ksize)
```

import unittest
import numpy as np
import importlib

def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)

class TestBlurFilters(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        global user_code
        user_code = importlib.import_module("user_code")

    def test_gaussian_blur_shape(self):
        expected_shape = user_code.image.shape
        arr = getattr(user_code, "gaussian_blurred", None)
        _dynamic_test(
            self,
            isinstance(arr, np.ndarray) and arr.shape == expected_shape,
            "Gaussian blurred image has correct shape and type.",
            f"The variable `gaussian_blurred` should be a NumPy array with shape {expected_shape}."
        )

    def test_median_blur_shape(self):
        expected_shape = user_code.image.shape
        arr = getattr(user_code, "median_blurred", None)
        _dynamic_test(
            self,
            isinstance(arr, np.ndarray) and arr.shape == expected_shape,
            "Median blurred image has correct shape and type.",
            f"The variable `median_blurred` should be a NumPy array with shape {expected_shape}."
        )

    def test_gaussian_blur_effect(self):
        original = user_code.image
        blurred = getattr(user_code, "gaussian_blurred", None)
        _dynamic_test(
            self,
            isinstance(blurred, np.ndarray) and not np.array_equal(blurred, original),
            "Gaussian blur changes image content.",
            "The variable `gaussian_blurred` should be a NumPy array and differ from `image`."
        )

    def test_median_blur_effect(self):
        original = user_code.image
        blurred = getattr(user_code, "median_blurred", None)
        _dynamic_test(
            self,
            isinstance(blurred, np.ndarray) and not np.array_equal(blurred, original),
            "Median blur changes image content.",
            "The variable `median_blurred` should be a NumPy array and differ from `image`."
        )

if __name__ == "__main__":
    unittest.main()


test_code.py

Dive deep into computer vision by mastering convolutional neural networks (CNNs) with TensorFlow and Keras. This advanced course covers essential concepts and practical skills, including image preprocessing, convolution and pooling operations, building and training CNN architectures, implementing object detection, and applying transfer learning to tackle real-world visual challenges. Gain hands-on experience in solving complex vision problems using industry-standard tools and techniques.

Noise Reduction and Smoothing

Gaussian Blurring (Smoothing Noise)

Median Blurring (Salt-and-Pepper Noise Removal)

解答