Unschärfefilter in OpenCV

Diese Demonstration zeigt, wie Bilder in OpenCV geglättet oder verwischt werden. Wir werden verschiedene Arten von Unschärfefiltern und ihre Verwendung am Ende dieses Artikels besprechen.

Verwenden Sie verschiedene Arten von Blur-Filtern in OpenCV

Das Glätten, auch als Weichzeichnen bekannt, ist eine der am häufigsten verwendeten Operationen in der Bildverarbeitung. Es wird häufig verwendet, um Rauschen aus Bildern zu entfernen.

Wir können verschiedene lineare Filter verwenden, da lineare Filter einfach zu erreichen und relativ schnell sind. In OpenCV sind verschiedene Arten von Filtern verfügbar, z. B. homogene, Gaußsche, Median- oder bilaterale Filter, die wir einzeln sehen werden.

Zuerst sehen wir den homogenen Filter. Das homogene Filter ist einfach, und jedes Ausgangspixel ist der Mittelwert seiner Kernnachbarn in einem homogenen Filter.

Alle Pixel tragen mit gleichem Gewicht bei, weshalb sie als homogene Filter bezeichnet werden. Mit anderen Worten, der Kernel ist eine Form, die wir auf ein Bild anwenden oder falten können.

Das numpy erstellt diese Art von quadratischem Kernel. In einem homogenen Filter sieht der Kernel also wie in diesem Bild aus.

In dem homogenen Filter ist der Kern K gleich 1 geteilt durch die Breite des Kerns multipliziert mit der Höhe des Kerns. Wenn wir mit dieser Formel einen Kernel von 5 mal 5 verwenden wollen, dann haben wir K gleich 1 dividiert durch 25 und wir haben eine 5 mal 5 Kernelmatrix von 1s.

Nun müssen wir diesen Kernel für die Bildfilterung mit filter2D() oder dem homogenen Filter erstellen. Zuerst lesen wir ein Bild mit der Methode imread().

IMG = cv2.imread("opencv-logo.jpg")

Wir müssen das Bild von BGR in RGB konvertieren, da matplotlib die Bilder im RGB-Format liest und OpenCV die Bilder im BGR-Format liest.

IMG = cv2.cvtColor(IMG, cv2.COLOR_BGR2RGB)

Wir müssen einen 5x5-Kernel mit der Methode ones() mit dem Datentyp float32 definieren und ihn durch 25 teilen.

K = np.ones((5, 5), np.float32) / 25

Jetzt können wir unser Ziel-Image definieren, indem wir den definierten Kernel unterstützen. Für den homogenen Filter wird eine Methode namens filter2D() verwendet.

Der erste Parameter ist das Quellbild, der zweite die gewünschte Tiefe des Zielbildes und der dritte der Kernel.

HMG = cv2.filter2D(IMG, -1, K)

In der nächsten Zeile durchlaufen wir eine for-Schleife und zeigen Bilder auf matplotlib im 1-zu-2-Format durch diese Schleife.

for j in range(2):
    plot.subplot(1, 2, j + 1), plot.imshow(IMGS[j], "gray")

Vollständiger Beispielquellcode:

import numpy as np
import matplotlib.pyplot as plot

IMG = cv2.imread("opencv-logo.jpg")
IMG = cv2.cvtColor(IMG, cv2.COLOR_BGR2RGB)

K = np.ones((5, 5), np.float32) / 25
HMG = cv2.filter2D(IMG, -1, K)


T = ["Original IMG", "2D Convolution"]
IMGS = [IMG, HMG]

for j in range(2):
    plot.subplot(1, 2, j + 1), plot.imshow(IMGS[j], "gray")
    plot.title(T[j])
    plot.xticks([]), plot.yticks([])

plot.show()

Wir können ein wenig Rauschen in den Ecken sehen, und nachdem die 2D-Faltung auf dieses Bild angewendet wurde, sind die Ecken leicht geglättet oder verschwommen. Das Rauschen wird durch diese Unschärfe entfernt oder unterdrückt, so dass dies eine Möglichkeit ist, ein Bild mit der Methode filter2D() zu verwischen.

Unschärfefilter

Eindimensionale Bilder können mit Tiefpassfiltern oder Hochpassfiltern gefiltert werden. Der Tiefpassfilter hilft, Rauschen oder Unschärfe des Bildes usw. zu entfernen, und der Hochpassfilter hilft, Kanten in den Bildern zu finden.

Um ein unscharfes Bild zu erhalten, müssen Sie das Bild mit dem Tiefpassfilter konvertieren. In OpenCV sind verschiedene Arten von Algorithmen verfügbar; Der erste Algorithmus ist die blur()-Methode.

Die blur()-Methode wird auch Mittelwertmethode genannt, die wir verwenden werden, um den Mittelwertalgorithmus anzuwenden, um ein unscharfes Bild zu erstellen. Diese Methode benötigt zwei Parameter: Der erste ist das Bild und der zweite ist der Kernel, der (5,5) sein wird.

import cv2
import numpy as np
import matplotlib.pyplot as plot

IMG = cv2.imread("opencv-logo.jpg")
IMG = cv2.cvtColor(IMG, cv2.COLOR_BGR2RGB)

K = np.ones((5, 5), np.float32) / 25
HMG = cv2.filter2D(IMG, -1, K)
BL = cv2.blur(IMG, (5, 5))

T = ["Original IMG", "2D Convolution", "Blur"]
IMGS = [IMG, HMG, BL]

for j in range(3):
    plot.subplot(1, 3, j + 1), plot.imshow(IMGS[j], "gray")
    plot.title(T[j])
    plot.xticks([]), plot.yticks([])

plot.show()

Das Ergebnis sieht zwischen 2D-Faltung und Unschärfe mehr oder weniger gleich aus, da wir die gleiche Art von Kernel auf beide Funktionen angewendet haben.

Gaußscher Filter

Sehen wir uns den nächsten Algorithmus an, nämlich den Gaußschen Filteralgorithmus. Der Gaußsche Filter ist nichts anderes als die Verwendung eines Kernels mit unterschiedlicher Gewichtung in x- und y-Richtung.

In der Ausgabe befinden sich die Pixel in der Mitte des Kernels mit einem höheren oder größeren Gewicht. Die Gewichte nehmen mit der Entfernung vom Nachbarschaftszentrum ab.

Die Pixel mit geringerer Gewichtung befinden sich auf der Seite, und die Pixel mit höherer Gewichtung befinden sich in der Mitte.

Wenn wir einen 5x5-Kernel nehmen, sieht sein Ergebnis so aus wie im Bild gezeigt.

Mal sehen, wie wir die Methode GaussianBlur() in OpenCV verwenden können. Die Parameter sind dieselben wie bei der blur()-Methode, also ist der erste Parameter das Eingabebild, der zweite unser Kernel und der dritte der Sigma-X-Wert.

import cv2
import numpy as np
import matplotlib.pyplot as plot

IMG = cv2.imread("eye.jpg")
IMG = cv2.cvtColor(IMG, cv2.COLOR_BGR2RGB)

K = np.ones((5, 5), np.float32) / 25
HMG = cv2.filter2D(IMG, -1, K)
BL = cv2.blur(IMG, (5, 5))
GB = cv2.GaussianBlur(IMG, (5, 5), 0)

T = ["Original IMG", "2D Convolution", "Blur", "GaussianBlur"]
IMGS = [IMG, HMG, BL, GB]

for j in range(4):
    plot.subplot(2, 2, j + 1), plot.imshow(IMGS[j], "gray")
    plot.title(T[j])
    plot.xticks([]), plot.yticks([])

plot.show()

Wir können beobachten, dass das Ergebnis der Methode GaussianBlur() besser ist als die der anderen Weichzeichnungsmethoden.

Sehen Sie sich das Originalbild an, das zu stark verrauscht ist. Sämtliches Rauschen wird nach Anwendung der Methode GaussianBlur() entfernt.

Die Methode GaussianBlur() ist also speziell darauf ausgelegt, das hochfrequente Rauschen aus einem Bild zu entfernen.

Medianfilter

Der Medianfilter ist etwas, das jeden Pixelwert durch den Median seines benachbarten Pixels ersetzt. Die Methode medianBlur() ist großartig, wenn es um ein Bild mit Salz-und-Pfeffer-Rauschen geht.

Wenn Sie mehr über das Salz-und-Pfeffer-Geräusch erfahren möchten, folgen Sie diesem Link.

Wir haben hier ein Bild; Einige Pixel sind verzerrt, einige sind weiße Punkte oder weißes Rauschen, und bei einigen ist schwarzes Rauschen zu sehen. Da die Pixel wie Salz verzerrt sind und die schwarzen Pixel wie Pfeffer aussehen, wird es als Salz-und-Pfeffer-Rauschen bezeichnet.

Lassen Sie uns dieses Bild als Quelle in der Methode medianBlur() verwenden. Das Quellbild ist der erste Parameter und der zweite die Kernelgröße.

Wir müssen beachten, dass die Kernelgröße ungerade sein muss, wie 3, 5, 7 usw., außer 1. Wenn Sie 1 verwenden, wird Ihnen das Originalbild angezeigt.

import cv2
import numpy as np
import matplotlib.pyplot as plot

IMG = cv2.imread("water.jpg")
IMG = cv2.cvtColor(IMG, cv2.COLOR_BGR2RGB)

K = np.ones((5, 5), np.float32) / 25
HMG = cv2.filter2D(IMG, -1, K)
BL = cv2.blur(IMG, (5, 5))
GB = cv2.GaussianBlur(IMG, (5, 5), 0)
MB = cv2.medianBlur(IMG, 5)

T = ["Original IMG", "2D Convolution", "Blur", "GaussianBlur", "medianBlur"]
IMGS = [IMG, HMG, BL, GB, MB]

for j in range(5):
    plot.subplot(2, 3, j + 1), plot.imshow(IMGS[j], "gray")
    plot.title(T[j])
    plot.xticks([]), plot.yticks([])

plot.show()

Unten sehen wir das beste Ergebnis, das wir mit der Methode medianBlur() erhalten.

Bilateraler Filter

Sehen wir uns den letzten Filter an, der als bilateraler Filter bezeichnet wird. Durch die Verwendung anderer Filter haben wir also nicht nur das Rauschen aufgelöst, sondern auch die Kanten geglättet.

Manchmal müssen wir die Kanten erhalten, was bedeutet, dass alle Kanten scharf bleiben, selbst wenn das Bild unscharf ist.

Die Methode bilateralFilter() nimmt das Bild als ersten Parameter. Der zweite Parameter ist der Durchmesser jedes beim Filtern verwendeten Pixels, der dritte Parameter ist die Sigma-Farbe und der vierte ist der Sigma-Abstand.

Die Sigma-Farbe ist das Filter Sigma im Farbraum, und der Sigma-Raum ist das Filter Sigma im Koordinatenraum.

import cv2
import numpy as np
import matplotlib.pyplot as plot

IMG = cv2.imread("lena-1.jpg")
IMG = cv2.cvtColor(IMG, cv2.COLOR_BGR2RGB)

K = np.ones((5, 5), np.float32) / 25
HMG = cv2.filter2D(IMG, -1, K)
BL = cv2.blur(IMG, (5, 5))
GB = cv2.GaussianBlur(IMG, (5, 5), 0)
MB = cv2.medianBlur(IMG, 5)
BF = cv2.bilateralFilter(IMG, 9, 75, 75)

T = [
    "Original IMG",
    "2D Convolution",
    "Blur",
    "GaussianBlur",
    "medianBlur",
    "bilateralFilter",
]
IMGS = [IMG, HMG, BL, GB, MB, BF]
plot.figure(figsize=(8, 6))
for j in range(6):
    plot.subplot(2, 3, j + 1), plot.imshow(IMGS[j], "gray")
    plot.title(T[j])
    plot.xticks([]), plot.yticks([])

plot.show()

Sehen Sie sich an, wie die Kanten viel besser erhalten bleiben, wenn die Methode bilateralFilter() angewendet wird. Der bilaterale Filter ist sehr effektiv beim Entfernen von Rauschen, während die Kanten scharf bleiben.