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

Rauschen in Bildern erscheint als unerwünschte Körnigkeit oder Verzerrung, häufig verursacht durch schlechte Lichtverhältnisse, Komprimierungsartefakte oder Sensorbeschränkungen. Glättungstechniken helfen, **Rauschen zu reduzieren und gleichzeitig wichtige Bilddetails zu erhalten**.


## Gaußsche Weichzeichnung (Rauschglättung)
Die Funktion `cv2.GaussianBlur` wendet eine **gaußsche Weichzeichnung** an, die das Bild glättet, indem Pixelwerte mit einem Gauß-Kernel gemittelt werden (ein gewichteter Durchschnitt, der zentralen Pixeln mehr Bedeutung beimisst):

- `cv2.GaussianBlur(src, ksize, sigmaX)`:  
  - `src`: das Quellbild, das weichgezeichnet werden soll;
  - `ksize`: Kernelgröße im Format `(width, height)`, beide Werte müssen ungerade sein (z. B. `(5, 5)`);
  - `sigmaX`: Standardabweichung in X-Richtung; steuert den Grad der Weichzeichnung.  
- Die Funktion reduziert Bildrauschen und Details, indem das Bild mit einer gaußschen Funktion gefaltet wird. Dies ist nützlich bei Aufgaben wie Kantenerkennung oder Vorverarbeitung vor der Schwellenwertbildung.

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

Im `cv2.GaussianBlur()`-Parameter `sigmaX` ist die **Standardabweichung des Gaußschen Kerns in X-Richtung** festgelegt, während derselbe Parameter in Y-Richtung (`sigmaY`) standardmäßig den Wert **0** hat. Wenn sowohl `sigmaX` als auch `sigmaY` den Wert 0 haben, **wird die Standardabweichung aus der Kernelgröße berechnet**.

Mehr erfahren

## Median-Filterung (Entfernung von Salz-und-Pfeffer-Rauschen)
Die Funktion `cv2.medianBlur` wendet einen **Medianfilter** an, der jeden Pixelwert durch den Medianwert der benachbarten Pixel im Kernel-Fenster ersetzt:

- `cv2.medianBlur(src, ksize)`:  
  - `src`: das zu filternde Quellbild;
  - `ksize`: Größe des quadratischen Kerns (muss eine ungerade Ganzzahl sein, z. B. `3`, `5`, `7`).  
- Die Median-Filterung ist besonders effektiv bei der Entfernung von **Salz-und-Pfeffer-Rauschen**, da sie Kanten erhält und isolierte Störpixel entfernt.

```
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

Tauchen Sie tief in das Gebiet des Computer Vision ein, indem Sie Convolutional Neural Networks (CNNs) mit TensorFlow und Keras beherrschen. Dieser fortgeschrittene Kurs behandelt grundlegende Konzepte und praktische Fähigkeiten, einschließlich Bildvorverarbeitung, Faltungs- und Pooling-Operationen, Aufbau und Training von CNN-Architekturen, Implementierung von Objekterkennung sowie Anwendung von Transfer Learning zur Lösung realer visueller Herausforderungen. Sammeln Sie praktische Erfahrungen bei der Lösung komplexer Vision-Probleme mit branchenüblichen Werkzeugen und Techniken.

Rauschreduzierung und Glättung

Gaußsche Weichzeichnung (Rauschglättung)

Median-Filterung (Entfernung von Salz-und-Pfeffer-Rauschen)

Lösung