Glättung kantengespeichert mit Python + OpenCV (BilateralFilter, NLMeansFilter)

Ein geglättetes und unscharfes Bild kann erhalten werden, indem die Pixelwerte um das Aufmerksamkeitspixel des Bildes unter Verwendung des folgenden Filters gemittelt werden.

\left(
\begin{matrix}
1/9 & 1/9 & 1/9 \\
1/9 & 1/9 & 1/9 \\
1/9 & 1/9 & 1/9
\end{matrix}
\right)

Dadurch wird das Bild jedoch insgesamt unscharf, sodass die Kanten gleichermaßen verschwommen sind. Wenn Sie die Kanten beibehalten, aber auch das Rauschen reduzieren möchten, verwenden Sie einen Filter dafür.

Bilateraler Filter

Bei der gewichteten Mittelung werden nicht nur die Pixelwerte um das interessierende Pixel gemittelt, sondern es wird vor allem reflektiert, was sich in der Nähe des interessierenden Pixels befindet. Wenn es darum geht, die Gewichte zu verteilen, sagt der Gauß-Filter, dass er gemäß der Normalverteilung verteilt werden soll. Die Gaußsche Verteilung mit dem Mittelwert 0 und der Dispersion ρ wird wie folgt ausgedrückt.

\frac{1}{ \sqrt{2 \pi \sigma}} \exp
\begin{pmatrix}
- 
\frac{x^2}{2\sigma ^ 2}
\end{pmatrix}

Dies ist eine Dimension. Wenn Sie sie also auf zwei Dimensionen erweitern

\frac{1}{ 2 \pi \sigma ^2} \exp
\begin{pmatrix}
- 
\frac{x^2 + y ^2}{2\sigma ^ 2}
\end{pmatrix}

Das Gaußsche Filter gewichtet den Abstand zwischen dem bemerkenswerten Pixel und dem peripheren Pixel, der durch die Gaußsche Funktion angenähert wird, aber das bilaterale Filter gewichtet auch die Differenz zwischen den Pixelwerten des bemerkenswerten Pixels und dem peripheren Pixel mit der Gaußschen Funktion. ing. Wenn der Unterschied im Pixelwert von dem interessierenden Pixel klein ist (= ähnlicher Farbton und Helligkeit), ist das Gewicht groß, und wenn der Unterschied im Pixelwert von dem interessierenden Pixel groß ist, ist das Gewicht klein. Wenn das Eingabebild f (i, j) und die Ausgabe g (i, j) ist

g(i,j) =
 \frac{ \sum_{n=-w}^{w} \sum_{m=-w}^{w} w(i,j,m,n) f(i+m, j+n) }

{\sum_{n=-w}^{w} \sum_{m=-w}^{w} w(i,j,m,n)}

w(i,j,m,n) = \exp 
\begin{pmatrix}
- \frac{m^2 + n^2}{2 \sigma_{1}^2}
\end{pmatrix}

\exp 
\begin{pmatrix}
- \frac{(f(i,j)-f(i+m, j+n))^2}
{2 \sigma_{2}^2}
\end{pmatrix}

Es wird eine lächerliche Formel. Die Gewichtung des Abstands zwischen dem Aufmerksamkeitspixel und dem peripheren Pixel wird durch die exp in der ersten Hälfte der Formel bezüglich w dargestellt, und die Differenz zwischen den Pixelwerten des Aufmerksamkeitspixels und des Berechnungszielpixels wird durch die exp in der zweiten Hälfte der Formel bezüglich w dargestellt. Es ist ein Filter für die Mittelwertbildung, aber w ist nicht so eingestellt, dass er 1 ergibt. Sie benötigen daher einen Nenner, um alle Kernelwerte zu addieren und 1 zu erhalten.

Referenz: http://imagingsolution.net/imaging/bilateralfilter/

cv2.bilateralFilter(src, d, sigmaColor, sigmaSpace[, dst[, borderType]]) → dst http://docs.opencv.org/3.0-last-rst/modules/imgproc/doc/filtering.html?highlight=laplacian#bilateralfilter

--src: Eingabebild --d: Bereich, der zum Verwischen des interessierenden Pixels verwendet wird --sigmaColor: Standardabweichung für Farbe. Wenn dies groß ist, wird ein großes Gewicht angenommen, selbst wenn der Unterschied in den Pixelwerten groß ist. --sigmaSpace: Standardabweichung für die Entfernung. Wenn dies groß ist, wird ein großes Gewicht angenommen, selbst wenn der Abstand zwischen den Pixeln groß ist.

import cv2
from matplotlib import pyplot as plt

img = cv2.imread('images.jpg', cv2.IMREAD_COLOR)
bi = cv2.bilateralFilter(img, 15, 20, 20)
bi2 = cv2.bilateralFilter(bi, 15, 20, 20)
bi3 = cv2.bilateralFilter(bi2, 15, 20, 20)

plt.subplot(2,2,1),plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title("original")
plt.xticks([]),plt.yticks([])
plt.subplot(2,2,2),plt.imshow(cv2.cvtColor(bi, cv2.COLOR_BGR2RGB))
plt.title("bi")
plt.xticks([]),plt.yticks([])
plt.subplot(2,2,3),plt.imshow(cv2.cvtColor(bi2, cv2.COLOR_BGR2RGB))
plt.title("bi2")
plt.xticks([]),plt.yticks([])
plt.subplot(2,2,4),plt.imshow(cv2.cvtColor(bi3, cv2.COLOR_BGR2RGB))
plt.title("bi3")
plt.xticks([]),plt.yticks([])

plt.show()

Nicht lokaler Mittelwertfilter

Die bilateralen Filtergewichte gemäß der Differenz zwischen dem Pixelwert des interessierenden Pixels und dem Pixelwert des peripheren Pixels, aber in dem nicht lokalen Mittelwertfilter ist der Bereich einschließlich des peripheren Pixels der periphere Bereich des interessierenden Pixels wie eine Vorlagenanpassung. Das Gewicht wird dadurch bestimmt, wie ähnlich sie sind.

Die Erklärung mit konkreten Bildern ist hier leicht zu verstehen. http://opencv.jp/opencv2-x-samples/non-local-means-filter

Zeremonie

w(i,j,m,n) = \exp 
\begin{pmatrix}
\frac{
\sum_{t=-w}^{w} \sum_{s=-w}^{w} (f(i+s,j+t) -f(i+m+s, j+n+t))^2
}
{}

\end{pmatrix}

Kann in der obigen Gleichung auf g (i, j) angewendet werden. Es scheint, dass der Bereich um das interessierende Pixel und der Bereich um die peripheren Pixel ähnlich sind, aber ehrlich gesagt verstehe ich die Bedeutung der Formel nicht ...

cv2.fastNlMeansDenoisingColored(src[, dst[, h[, hColor[, templateWindowSize[, searchWindowSize]]]]]) http://docs.opencv.org/3.0-beta/modules/photo/doc/denoising.html

--src: Eingabebild (Farbe) --templateWindowSize: Größe der Peripheriebereichsvorlage --searchWindowSize: Bereichsgröße zum Suchen nach Gewichten --h: Der Grad der Glättung des Filters der Helligkeitskomponente, das Rauschen nimmt ab, wenn es groß ist, wirkt sich aber auch auf den Randteil aus.

--hColor: Der Glättungsgrad des Farbkomponentenfilters 10 reicht aus

Referenz: http://ishidate.my.coocan.jp/opencv310_6/opencv310_6.htm

import cv2
from matplotlib import pyplot as plt

img = cv2.imread('images.jpg', cv2.IMREAD_COLOR)

dst = cv2.fastNlMeansDenoisingColored(img,None,10,10,7,21)


plt.subplot(2,1,1),plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title("original")
plt.xticks([]),plt.yticks([])
plt.subplot(2,1,2),plt.imshow(cv2.cvtColor(dst, cv2.COLOR_BGR2RGB))
plt.title("NLMeans")