Summary  
This chapter explains how to apply Gaussian and median filters to smooth images and reduce noise while preserving important details and edges.

General domain of usage  
Computer vision

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

Comprehensive introduction to Computer Vision, focusing on machine perception and interpretation of visual data. Covers image preprocessing, feature extraction, object detection, and deep learning techniques used in modern vision systems.

Computer vision enables machines to interpret and analyze visual data, mimicking human perception. This section covers the basics of image representation, color models, and mathematical foundations essential for understanding how computers process images. You'll explore real-world applications, from autonomous vehicles to medical imaging, and learn how Computer vision integrates with AI and machine learning. 

OpenCV is a powerful library for image manipulation and computer vision tasks. This section covers essential techniques like image filtering, transformations, edge detection, and segmentation. You'll learn how to perform blurring, thresholding, contour detection, and feature extraction to enhance and analyze images efficiently.

CNNs process visual data using convolution, pooling, and activation layers to extract features for tasks like image classification and object detection. Key components include padding, convolution for feature extraction, pooling for complexity reduction, and activation for non-linearity. Popular architectures like AlexNet, VGG, and ResNet power AI in healthcare, autonomy, and security.

Object detection is a fundamental task in computer vision that involves identifying and localizing objects within an image. Unlike image classification, which assigns a single label to an entire image, object detection not only classifies objects but also determines their positions using bounding boxes. This section covers key techniques and algorithms used in object detection, ranging from traditional methods to deep learning-based approaches like YOLO and U-Net.

Computer vision has significantly advanced over the years, shifting from basic image processing methods to complex deep learning techniques. This section delves into the latest innovations in computer vision, focusing on transfer learning, facial recognition, and image generation. We will explore the benefits of pre-trained models on performance, the principles of facial recognition technology, and the way AI creates images through deep learning.

Noise Reduction and Smoothing

Gaussian Blurring (Smoothing Noise)

Median Blurring (Salt-and-Pepper Noise Removal)

解答