[PYTHON] 100 Schläge bei der Bildverarbeitung !! (011-020) Frühes Spiel
1. Zuallererst
Üben Sie dies, um die technischen Möglichkeiten der Bildvorverarbeitung zu verbessern 100 Klopfen für die Bildverarbeitung !! Ich werde es mit Colaboratory machen, damit es einfach ist, loszulegen. Wir werden daran arbeiten, das Ziel in zwei Wochen zu erreichen. Ich werde es sorgfältig erklären. Bitte stellen Sie eine Frage! 001 - 010 ist über den Link auf der rechten Seite Knock 100 Bildverarbeitung !! (001 - 010) Sorgfältig und sorgfältig
2. Vorbereitung
Eingeführte Bibliotheken usw. wie folgt.
python
#Bibliothek importieren
from google.colab import drive
import numpy as np
import matplotlib.pyplot as plt
import cv2
from google.colab.patches import cv2_imshow
#Laden von Bildern
img = cv2.imread('Bildpfad/imori.jpg')
img_noise = cv2.imread('Bildpfad/imori_noise.jpg')
#Zur Bildspeicherung
OUT_DIR = 'Zielpfad ausgeben/OUTPUT/'
3. Erklärung
Q.11 Glättungsfilter
Implementieren Sie einen Glättungsfilter (3x3). Der Glättungsfilter ist ein Filter, der den Durchschnittswert der Pixel im Filter ausgibt.
A11
"""
Glättungsfilter
cv2.filter2D(src, -1, kernel)
src Eingabebild
Kernel Filter Kernel(* Geben Sie als NumPy-Array an)
"""
#Kernel filtern
kernel = np.ones((3,3),np.float32)/9
#Glättungsfilter
img11 = cv2.filter2D(img, -1, kernel)
#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans11.jpg', img11)
#Bild anzeigen
cv2_imshow(img11)
cv2.waitKey(0)
cv2.destroyAllWindows()
Referenz: [Python / OpenCV] Glättung / Konturerkennung durch räumliche Filterung Referenz: Anfänger sein wollen
Q.12. Bewegungsfilter
Implementieren Sie einen Bewegungsfilter (3x3).
A12
def motion_filter(img, k_size=3):
"""
Bewegungsfilter(Ein Filter, der einen diagonalen Durchschnitt annimmt)
parameters
-------------------------
param1: numpy.Bild im ndarray-Format
param2:Kernelgröße
returns
-------------------------
(130x130)Numpy.Bild im ndarray-Format
"""
#Holen Sie sich Bildhöhe, -breite und -farbe
H, W, C = img.shape
#Kernel(numpy.diag()Diagonale Komponenten mit extrahieren)
K = np.diag([1] * k_size).astype(np.float) # array([[1., 0., 0.],[0., 1., 0.],[0., 0., 1.]])
K /= k_size # array([[0.33333333, 0., 0.],[0., 0.33333333, 0.],[0., 0., 0.33333333]])
#Keine Polsterung
pad = k_size // 2
out = np.zeros((H + pad * 2, W + pad * 2, C), dtype=np.float) #out.shape >>> (130, 130, 3)
out[pad:pad+H, pad:pad+W] = img.copy().astype(np.float)
tmp = out.copy()
#Filtern
for y in range(H):
for x in range(W):
for c in range(C):
out[pad + y, pad + x, c] = np.sum(K * tmp[y:y+k_size, x:x+k_size, c])
out = out[pad: pad + H, pad: pad + W].astype(np.uint8)
return out
#Bewegungsfilter
img12 = motion_filter(img, k_size=3)
#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans12.jpg', img12)
#Bild anzeigen
cv2_imshow(img12)
cv2.waitKey(0)
cv2.destroyAllWindows()
Q.13. MAX-MIN-Filter
Implementieren Sie den MAX-MIN-Filter (3x3). Der MAX-MIN-Filter ist ein Filter, der die Differenz zwischen dem Maximalwert und dem Minimalwert der Pixel im Filter ausgibt und einer der Kantenerkennungsfilter ist. Die Kantenerkennung dient zum Erkennen von Linien in einem Bild, und eine solche Operation zum Extrahieren von Informationen in einem Bild wird als Merkmalsextraktion bezeichnet. Die Kantenerkennung filtert häufig Graustufenbilder.
A13
def max_min_filter(img, k_size=3):
"""
Max-Min Filter(Ein Filter, der einen diagonalen Durchschnitt annimmt)
Da es sich um einen Graustufenprozess handelt, wird er in Fälle für Farbbilder und Fälle unterteilt.
parameters
-------------------------
param1: numpy.Bild im ndarray-Format
param2:Kernelgröße
returns
-------------------------
(130x130)Numpy.Bild im ndarray-Format
"""
#Wenn das Eingabebild Farbe ist
if len(img.shape) == 3:
# H(Höhe), W(Breite), C(Farbe)
H, W, C = img.shape
#Keine Polsterung
pad = k_size // 2
out = np.zeros((H + pad * 2, W + pad * 2, C), dtype=np.float) #out.shape >>> (130, 130, 3)
out[pad:pad+H, pad:pad+W] = img.copy().astype(np.float)
tmp = out.copy()
#Filtern
for y in range(H):
for x in range(W):
for c in range(C):
#Subtrahieren Sie das Minimum vom Maximum im 3x3-Kernel
out[pad + y, pad + x, c] = np.max(tmp[y:y+k_size, x:x+k_size, c]) - np.min(tmp[y:y+k_size, x:x+k_size, c])
out = out[pad: pad + H, pad: pad + W].astype(np.uint8)
#Wenn das Eingabebild Graustufen ist
else:
H, W = img.shape
#Keine Polsterung
pad = k_size // 2
out = np.zeros((H + pad * 2, W + pad * 2), dtype=np.float)
out[pad:pad+H, pad:pad+W] = img.copy().astype(np.float)
tmp = out.copy()
#Filtern
for y in range(H):
for x in range(W):
#Subtrahieren Sie das Minimum vom Maximum im 3x3-Kernel
out[pad + y, pad + x] = np.max(tmp[y:y+k_size, x:x+k_size]) - np.min(tmp[y:y+k_size, x:x+k_size])
out = out[pad: pad + H, pad: pad + W].astype(np.uint8)
return out
# Max-Min Filter
img13 = max_min_filter(img, k_size=3)
#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans13.jpg', img13)
#Bild anzeigen
cv2_imshow(img13)
cv2.waitKey(0)
cv2.destroyAllWindows()
Referenz: Murakami Laboratory Image Processing - Image Processing / Understanding Laboratory
Q.14 Differentialfilter
Implementieren Sie einen Differenzfilter (3x3). Das Differenzfilter ist ein Filter, das die Kante eines Abschnitts extrahiert, in dem eine plötzliche Helligkeitsänderung auftritt, und die Differenz zwischen benachbarten Pixeln berücksichtigt. Es ist der Teil, in dem sich die Helligkeit drastisch ändert, der zu einer Kante im Bild wird. Die Farbe des roten Teils ändert sich kaum, aber die Farbe des blauen Rahmens ändert sich drastisch. Diese Änderung wird zur Kante.
A14
"""
cv2.Sobel(src, ddepth, dx, dy[, dst[, ksize[, scale[, delta[, borderType]]]]])
src:Bild eingeben
ddepth:Ausgabe Farbtiefe
dx:Differenzierungsgrad in x-Richtung
dy:Die Reihenfolge der Differenzierung in y-Richtung
ksize:Kerngröße 1, 3, 5,Geben Sie einen von 7 an
"""
#Seitliche Richtung
dx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
#Längsrichtung
dy = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans14_v.jpg', dy)
cv2.imwrite(OUT_DIR + 'ans14_h.jpg', dx)
#Bild anzeigen
cv2_imshow(dy)
cv2_imshow(dx)
cv2.waitKey(0)
cv2.destroyAllWindows()
Eindruck, dass der weiße Teil klarer ist als das Bild der Modellantwort
Referenz: Kantenextraktion mit Python + OpenCV (Sobel-Filter, Laplace-Filter)
Q.15. Prewitt-Filter
Implementieren Sie den Prewitt-Filter (3x3). Der Prewitt-Filter ist eine Art Kantenextraktionsfilter und wird durch die folgende Gleichung definiert. Dies ist eine Erweiterung des Differentialfilters auf 3x3.
A15
"""
Prewitt(Verhindern)Ist einer der räumlichen Filter, die Konturen aus einem Bild extrahieren
cv2.filter2D(src, -1, kernel)
src Eingabebild
cv2.CV_64F float64
Kernel Filter Kernel(* Geben Sie als NumPy-Array an)
"""
#Kernel (zur horizontalen und vertikalen Konturerkennung)
kernel_x = np.array([[1, 0, -1],
[1, 0, -1],
[1, 0, -1]])
kernel_y = np.array([[1, 1, 1],
[0, 0, 0],
[-1, -1, -1]])
dx = cv2.filter2D(gray, cv2.CV_64F, kernel_x)
dy = cv2.filter2D(gray, cv2.CV_64F, kernel_y)
#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans15_v.jpg', dy)
cv2.imwrite(OUT_DIR + 'ans15_h.jpg', dx)
#Bild anzeigen
cv2_imshow(dy)
cv2_imshow(dx)
cv2.waitKey(0)
cv2.destroyAllWindows()
Referenz: Differentialfilter erster Ordnung Prewitt-Filter - Kantenextraktion des Bildes Referenz: [Python / OpenCV] Konturerkennung mit Prewitt-Filter
Q.16 Sobel-Filter
Implementieren Sie den Sobel-Filter (3x3). Der Sobel-Filter ist auch ein Filter, der Kanten extrahiert und durch die folgende Gleichung definiert wird. Dies ist ein Filter, der den zentralen Teil des Prewitt-Filters gewichtet.
A16
"""
Der Sobel-Filter betont auch Kanten mit geringem Helligkeitsunterschied.
cv2.filter2D(src, -1, kernel)
src Eingabebild
cv2.CV_64F float64
Kernel Filter Kernel(* Geben Sie als NumPy-Array an)
"""
#Kernel (zur horizontalen und vertikalen Konturerkennung)
kernel_x = np.array([[1, 0, -1],
[2, 0, -2],
[1, 0, -1]])
kernel_y = np.array([[1, 2, 1],
[0, 0, 0],
[-1, -2, -1]])
dx = cv2.filter2D(gray, cv2.CV_64F, kernel_x)
dy = cv2.filter2D(gray, cv2.CV_64F, kernel_y)
#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans16_v.jpg', dy)
cv2.imwrite(OUT_DIR + 'ans16_h.jpg', dx)
#Bild anzeigen
cv2_imshow(dy)
cv2_imshow(dx)
cv2.waitKey(0)
cv2.destroyAllWindows()
Referenz: Differentialfilter erster Ordnung Sobel-Filterkantenextraktion des Bildes Referenz: [Python / OpenCV] Konturerkennung mit Prewitt-Filter
Q.17. Laplace-Filter
Implementieren Sie den Laplace-Filter. Der Laplace-Filter ist ein Filter, der Kanten durch quadratische Differenzierung der Helligkeit erkennt. Da digitale Bilder diskrete Daten sind, werden die Differenzen erster Ordnung in x- und y-Richtung durch die folgenden Gleichungen ausgedrückt. (Wie Differentialfilter)
A17
"""
Laplace-Filter(Laplacian Filter)Ist ein räumlicher Filter, der mithilfe einer quadratischen Differenzierung Konturen aus einem Bild extrahiert
cv2.filter2D(src, -1, kernel)
src Eingabebild
cv2.CV_64F float64
Kernel Filter Kernel(* Geben Sie als NumPy-Array an)
"""
#Kernel
kernel = np.array([[0, 1, 0],
[1, -4, 1],
[0, 1, 0]])
#Laplace-Filter
img17 = cv2.filter2D(gray, cv2.CV_64F, kernel)
#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans17.jpg', img17)
#Bild anzeigen
cv2_imshow(img17)
cv2.waitKey(0)
cv2.destroyAllWindows()
Referenz: [Python / OpenCV] Konturerkennung mit Laplace-Filter (Kantenextraktion)
Q.18. Prägefilter
Implementieren Sie den Prägefilter. Der Prägefilter ist ein Filter, der den Gliederungsteil hervorhebt und durch die folgende Formel definiert wird.
A18
"""
Geprägter Filter(Emboss Filter)Ist eine Raumfüllung, die den Konturteil betont
cv2.filter2D(src, -1, kernel)
src Eingabebild
cv2.CV_64F float64
Kernel Filter Kernel(* Geben Sie als NumPy-Array an)
"""
#Kernel
kernel = np.array([[-2, -1, 0],
[-1, 1, 1],
[0, 1, 2]])
#Laplace-Filter
img18 = cv2.filter2D(gray, cv2.CV_64F, kernel)
#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans18.jpg', img18)
#Bild anzeigen
cv2_imshow(img18)
cv2.waitKey(0)
cv2.destroyAllWindows()
Referenz: [Python / OpenCV] Prozess mit Prägefilter
Q.19. LoG-Filter
Implementieren Sie einen LoG-Filter (Sigma = 3, Kernelgröße = 5) und erkennen Sie die Kanten von imori_noise.jpg. Der LoG-Filter ist der Laplace-Filter von Gauß, ein Filter, der ein Bild mit einem Gauß-Filter glättet und dann Konturen mit einem Laplace-Filter extrahiert. Da das Laplace-Filter eine quadratische Differenzierung vornimmt, unterdrückt das Gauß-Filter das Rauschen im Voraus, um zu verhindern, dass das Rauschen betont wird. Der LoG-Filter wird durch die folgende Gleichung definiert.
A19
"""
LoG-Filter(Laplacian Of Gaussian Filter)Ist ein Filter, der einen Gaußschen Filter und einen Laplace-Filter kombiniert.
Nachdem das Bild mit dem Gaußschen Filter geglättet wurde, um das Rauschen zu reduzieren, extrahiert der Laplace-Filter die Kontur.
Gaußscher Filter
cv2.GaussianBlur(src, ksize, sigmaX)
src:Bild eingeben, ksize:Kernelgröße, sigmaX:Gaußsches Verteilungssigma_x
Laplace-Filter
cv2.filter2D(src, -1, kernel)
src Eingabebild
cv2.CV_64F float64
Kernel Filter Kernel(* Geben Sie als NumPy-Array an)
"""
#Gaußscher Filter
gauss_img = cv2.GaussianBlur(gray_noise, ksize=(3, 3), sigmaX=1.3)
#Kernel
kernel = np.array([[0, 0, 1, 0, 0],
[0, 1, 2, 1, 0],
[1, 2, -16, 2, 1],
[0, 1, 2, 1, 0],
[0, 0, 1, 0, 0]])
#Laplace-Filter
img19 = cv2.filter2D(gauss_img, cv2.CV_64F, kernel)
#Speichern Sie das Ergebnis
cv2.imwrite(OUT_DIR + 'ans19.jpg', img19)
#Bild anzeigen
cv2_imshow(img19)
cv2.waitKey(0)
cv2.destroyAllWindows()
Ein anderes Bild als die Antwort. Aber wenn ich einen Laplace-Filter verwende, fühle ich mich so. Bitte lassen Sie mich wissen, wenn Sie einen Fehler machen.
Referenz: [Bildverarbeitung] LoG-Filterprinzip / Funktionen / Berechnungsformel
Q.20. Histogrammanzeige
Verwenden Sie matplotlib, um das Histogramm von imori_dark.jpg anzuzeigen. Das Histogramm ist ein Diagramm der Anzahl der Auftritte von Pixeln. Da matplotlib bereits eine Funktion namens hist () hat, verwenden Sie diese.
A
#Histogramm
"""
matplotlib.pyplot.hist(x, bins=10, range=None, normed=False, weights=None,
cumulative=False, bottom=None, histtype='bar',
align='mid', orientation='vertical', rwidth=None,
log=False, color=None, label=None, stacked=False,
hold=None, data=None, **kwargs)
x (Verpflichtend)Ein Array von Rohdaten zum Erstellen eines Histogramms.
Behälter Behälter Behälter(Leiste zum Anzeigen)Anzahl der. Anzahl der Klassen.(Standardwert: 10)
Geben Sie die minimalen und maximalen Werte für den Bereichsbereich an.(Standardwert: (x.min(), x.max()))
rwidth Geben Sie die Breite jedes Balkens als numerischen Wert oder Array an.
"""
# ravel:Mehrdimensionale Liste zu eindimensionaler Liste,Anzahl der Behälter:255,Bereich 0~255
plt.hist(img_dark.ravel(), bins=255, rwidth=0.8, range=(0, 255))
plt.savefig("out.png ")
plt.show()
Referenz: Data Science mit Python
Impressionen
In der offiziellen Version wird numpy verwendet und dies geschieht nach dem Prinzip, aber OpenCV wird so oft wie möglich verwendet, um die Implementierung zu vereinfachen.
Recommended Posts