Einführung
Hallo Leser!
OpenCV – Open Source Computer Vision. Es ist eines der am häufigsten verwendeten Werkzeuge für Bildverarbeitungs- und künstliche Sehaufgaben. Wird in verschiedenen Anwendungen wie der Gesichtserkennung verwendet, Videoaufnahme, sich bewegende Objekte verfolgen, Offenbarung von Gegenständen, heutzutage in Covid-Anwendungen wie der Maskenerkennung, Social Distancing und vieles mehr. Wenn Sie mehr über OpenCV erfahren möchten, Überprüfen Sie dies Verknüpfung.
📌Wenn Sie mehr über Python-Bibliotheken für die Bildverarbeitung erfahren möchten, Überprüfen Sie diesen Link.
📌Wenn Sie lernen möchten, wie man Bilder mit NumPy verarbeitet, 😋überprüfe diesen Link.
📌Für weitere Artikel😉, Klicke hier
In diesem Blog, Ich werde OpenCV sehr detailliert behandeln und einige der wichtigsten Aufgaben in der Bildverarbeitung durch praktische Umsetzung abdecken. Also lasst uns anfangen !! ⌛
Bild Quelle
Inhaltsverzeichnis
- Kantenerkennung und Bildverläufe
- Erweiterung, Öffnung, Schließung und Erosion
- Perspektiventransformation
- Pyramiden von Bildern
- Trimmen
- geklettert, Interpolationen und Größenänderung
- Schwellenwert, adaptive Schwellenwertbildung und Binarisierung
- Scharf
- Fleck
- Konturen
- Linienerkennung mit harten Linien
- Ecken finden
- Kreise und Ellipsen zählen
Bild Quelle
Kantenerkennung und Bildverläufe
Es ist eine der grundlegendsten und wichtigsten Techniken in der Bildverarbeitung. Überprüfen Sie den folgenden Code für eine vollständige Implementierung. Für mehr Informationen, Sieh dir das an Verknüpfung.
image = cv2.imread('fruit.jpg')
image = cv2.cvtColor(Bild, cv2.COLOR_BGR2RGB)
hgt, wdt,_ = Bild.Form
# Sobel Kanten
x_sobel = cv2.Sobel(Bild, cv2.CV_64F, 0, 1, kgröße=5)
y_sobel = cv2.Sobel(Bild, cv2.CV_64F, 1, 0, kgröße=5)
plt.figur(Feigengröße=(20, 20))
plt.subplot(3, 2, 1)
plt.titel("Original")
plt.imshow(Bild)
plt.subplot(3, 2, 2)
plt.titel("Sobel X")
plt.imshow(x_sobel)
plt.subplot(3, 2, 3)
plt.titel("Sobel Y")
plt.imshow(y_sobel)
sobel_or = cv2.bitwise_or(x_sobel, y_sobel)
plt.subplot(3, 2, 4)
plt.imshow(sobel_or)
laplacian = cv2.Laplacian(Bild, cv2.CV_64F)
plt.subplot(3, 2, 5)
plt.titel("Laplace")
plt.imshow(Laplazianer)
## Es gibt zwei Werte: Schwelle1 und Schwelle2.
## Diejenigen Gradienten, die größer sind als Schwellenwert2 => als Kante betrachtet
## Diejenigen Gradienten, die unterhalb des Schwellenwerts liegen1 => gilt nicht als Kante.
## Jene Gradienten Werte, die zwischen Schwellenwert1 und Schwellenwert2 liegen => entweder als Kanten oder Nicht-Kanten klassifiziert
# Der erste Schwellengradient
canny = cv2.Canny(Bild, 50, 120)
plt.subplot(3, 2, 6)
plt.imshow(schlau)
Erweiterung, Öffnung, Schließung und Erosion
Dies sind zwei grundlegende Bildverarbeitungsvorgänge. Sie werden verwendet, um Geräusche zu eliminieren, Finden Sie ein Intensitätsloch oder eine Erhebung in einem Bild und vieles mehr. Sehen Sie sich den folgenden Code für eine praktische Implementierung an. Für mehr Informationen, Sieh dir das an Verknüpfung.
image = cv2.imread('LinuxLogo.jpg')
image = cv2.cvtColor(Bild, cv2.COLOR_BGR2RGB)
plt.figur(Feigengröße=(20, 20))
plt.subplot(3, 2, 1)
plt.titel("Original")
plt.imshow(Bild)
Kernel = np.ones((5,5), z.B. uint8)
Erosion = cv2.erode(Bild, Kernel, Iterationen = 1)
plt.subplot(3, 2, 2)
plt.titel("Erosion")
plt.imshow(Erosion)
Dilatation = cv2.dilate(Bild, Kernel, Iterationen = 1)
plt.subplot(3, 2, 3)
plt.titel("Erweiterung")
plt.imshow(Erweiterung)
Eröffnung = cv2.morphologyEx(Bild, cv2.MORPH_OPEN, Kernel)
plt.subplot(3, 2, 4)
plt.titel("Öffnung")
plt.imshow(Öffnung)
schließen = cv2.morphologyEx(Bild, cv2.MORPH_CLOSE, Kernel)
plt.subplot(3, 2, 5)
plt.titel("Schließen")
plt.imshow(Schließen)
Perspektiventransformation
Um bessere Informationen zu einem Bild zu erhalten, wir können die Perspektive eines Videos oder eines Bildes ändern. In dieser Verwandlung, wir müssen die Punkte in einem Bild angeben, von denen wir Informationen aufnehmen möchten, indem wir die Perspektive ändern. En OpenCV, wir verwenden zwei Funktionen für die perspektivische Transformation getPerspectiveTransform () und später warpPerspective (). Überprüfen Sie den folgenden Code für eine vollständige Implementierung. Für mehr Informationen, Sieh dir das an Verknüpfung.
image = cv2.imread('scan.jpg')
image = cv2.cvtColor(Bild, cv2.COLOR_BGR2RGB)
plt.figur(Feigengröße=(20, 20))
plt.subplot(1, 2, 1)
plt.titel("Original")
plt.imshow(Bild)
Punkte_A = np.float32([[320,15], [700,215], [85,610], [530,780]])
Punkte_B = np.float32([[0,0], [420,0], [0,594], [420,594]])
M = cv2.getPerspectiveTransform(Punkte_A, Punkte_B)
warped = cv2.warpPerspective(Bild, m, (420,594))
plt.subplot(1, 2, 2)
plt.titel("warpPerspective")
plt.imshow(verzogen)
Pyramiden von Bildern
Es ist eine sehr nützliche Technik, wenn wir die Erkennung von Objekten skalieren müssen. OpenCV verwendet zwei gängige Arten von Bildpyramiden Gaussiano und Laplace Pyramide. Verwenden Sie die Live () Ja pyrDown () Funktion in OpenCV zum Verkleinern oder Vergrößern eines Bildes. Sehen Sie sich den folgenden Code für eine praktische Implementierung an. Für mehr Informationen, Sieh dir das an Verknüpfung.
image = cv2.imread('butterfly.jpg')
image = cv2.cvtColor(Bild, cv2.COLOR_BGR2RGB)
plt.figur(Feigengröße=(20, 20))
plt.subplot(2, 2, 1)
plt.titel("Original")
plt.imshow(Bild)
kleiner = cv2.pyrDown(Bild)
größer = cv2.pyrUp(kleiner)
plt.subplot(2, 2, 2)
plt.titel("Kleiner")
plt.imshow(kleiner)
plt.subplot(2, 2, 3)
plt.titel("Größer")
plt.imshow(größer)
Trimmen
Es ist eine der wichtigsten und grundlegendsten Techniken in der Bildverarbeitung, Zuschneiden wird verwendet, um einen bestimmten Teil eines Bildes zu erhalten. So beschneiden Sie ein Bild. Sie benötigen nur die Koordinaten eines Bildes entsprechend Ihrem Interessengebiet. Für eine vollständige Analyse, siehe folgenden Code in OpenCV.
image = cv2.imread('messi.jpg')
image = cv2.cvtColor(Bild, cv2.COLOR_BGR2RGB)
plt.figur(
Aigsize=(20, 20))
plt.subplot(2, 2, 1)
plt.titel("Original")
plt.imshow(Bild)
hgt, wdt = image.shape[:2]
start_row, start_col = int(hgt * .25), int(wdt * .25)
end_row, end_col = int(Höhe * .75), int(Breite * .75)
abgeschnitten = Bild[start_row:end_row , start_col:end_col]
plt.subplot(2, 2, 2)
plt.imshow(abgeschnitten)
geklettert, Interpolationen und Größenänderung
Größenänderung es ist eine der einfachsten Aufgaben in OpenCV. Bietet ein Größe ändern () Übernehmende Funktionen ParameterDas "Parameter" sind Variablen oder Kriterien, die zur Definition von, ein Phänomen oder System zu messen oder zu bewerten. In verschiedenen Bereichen wie z.B. Statistik, Informatik und naturwissenschaftliche Forschung, Parameter sind entscheidend für die Etablierung von Normen und Standards, die die Datenanalyse und -interpretation leiten. Ihre richtige Auswahl und Handhabung sind entscheidend, um genaue und relevante Ergebnisse in jeder Studie oder jedem Projekt zu erhalten.... als Bild, Bild in Ausgabegröße, Interpolation, Skala x und Skala y. Überprüfen Sie den folgenden Code für eine vollständige Implementierung.
image = cv2.imread('/kaggle/input/opencv-samples-images/data/fruits.jpg')
image = cv2.cvtColor(Bild, cv2.COLOR_BGR2RGB)
plt.figur(Feigengröße=(20, 20))
plt.subplot(2, 2, 1)
plt.titel("Original")
plt.imshow(Bild)
image_scaled = cv2.resize(Bild, Keiner, fx=0,75, fy=0,75)
plt.subplot(2, 2, 2)
plt.titel("Skalierung - Lineare Interpolation")
plt.imshow(image_scaled)
img_scaled = cv2.resize(Bild, Keiner, fx=2, fy=2, Interpolation = cv2.INTER_CUBIC)
plt.subplot(2, 2, 3)
plt.titel("Skalierung - Kubische Interpolation")
plt.imshow(img_scaled)
img_scaled = cv2.resize(Bild, (900, 400), Interpolation = cv2.INTER_AREA)
plt.subplot(2, 2, 4)
plt.titel("Skalierung - Verzerrte Größe")
plt.imshow(img_scaled)
Schwellenwert, adaptive Schwellenwertbildung und Binarisierung
Überprüfen Sie den folgenden Code für eine vollständige Implementierung. Für mehr Informationen, Sieh dir das an Verknüpfung.
# Laden Sie unser neues Bild
image = cv2.imread('Origin_of_Species.jpg', 0)
plt.figur(Feigengröße=(30, 30))
plt.subplot(3, 2, 1)
plt.titel("Original")
plt.imshow(Bild)
rechts,schwelle1 = cv2.schwelle(Bild, 127, 255, cv2.THRESH_BINARY)
plt.subplot(3, 2, 2)
plt.titel("Schwellenwert Binär")
plt.imshow(schwelle1)
image = cv2.GaussianBlur(Bild, (3, 3), 0)
Schwelle = cv2.adaptiveThreshold(Bild, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 3, 5)
plt.subplot(3, 2, 3)
plt.titel("Adaptiver mittlerer Schwellenwert")
plt.imshow(dreschen)
_, th2 = cv2.threshold(Bild, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
plt.subplot(3, 2, 4)
plt.titel("Otsu's Thresholding")
plt.imshow(th2)
plt.subplot(3, 2, 5)
Unschärfe = cv2.GaussianBlur(Bild, (5,5), 0)
_, th3 = cv2.threshold(verwischen, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
plt.titel("Guassian Otsus Thresholding")
plt.imshow(th3)
plt.zeigen()
Scharf
Überprüfen Sie den folgenden Code, um ein Bild mit OpenCV zu fokussieren. Für mehr Informationen, Sieh dir das an Verknüpfung
image = cv2.imread('building.jpg')
image = cv2.cvtColor(Bild, cv2.COLOR_BGR2RGB)
plt.figur(Feigengröße=(20, 20))
plt.subplot(1, 2, 1)
plt.titel("Original")
plt.imshow(Bild)
kernel_sharpening = np.array([[-1,-1,-1],
[-1,9,-1],
[-1,-1,-1]])
geschärft = cv2.filter2D(Bild, -1, Kernelschärfung)
plt.subplot(1, 2, 2)
plt.titel("Bildschärfen")
plt.imshow(geschärft)
plt.zeigen()
Fleck
Überprüfen Sie den folgenden Code, um ein Bild mit OpenCV . unscharf zu machen. Für mehr Informationen, Sieh dir das an Verknüpfung
image = cv2.imread('home.jpg')
image = cv2.cvtColor(Bild, cv2.COLOR_BGR2RGB)
plt.figur(Feigengröße=(20, 20))
plt.subplot(2, 2, 1)
plt.titel("Original")
plt.imshow(Bild)
kernel_3x3 = np.ones((3, 3), z.B. float32) / 9
verschwommen = cv2.filter2D(Bild, -1, Kernel_3x3)
plt.subplot(2, 2, 2)
plt.titel("3x3 Kernel-Unschärfe")
plt.imshow(verschwommen)
kernel_7x7 = np.ones((7, 7), z.B. float32) / 49
unscharf2 = cv2.filter2D(Bild, -1, Kernel_7x7)
plt.subplot(2, 2, 3)
plt.titel("7x7 Kernel-Unschärfe")
plt.imshow(verschwommen2)
Konturen
Bildkonturen: ist eine Möglichkeit, die strukturellen Konturen eines Objekts in einem Bild zu identifizieren. Es ist nützlich, die Form eines Objekts zu identifizieren. OpenCV bietet eine findContours Funktion, bei der Sie knifflige Kanten als Parameter übergeben müssen. Überprüfen Sie den folgenden Code für eine vollständige Implementierung. Für mehr Informationen, Sieh dir das an Verknüpfung.
# Laden Sie die Daten
image = cv2.imread('pic.png')
image = cv2.cvtColor(Bild, cv2.COLOR_BGR2RGB)
plt.figur(Feigengröße=(20, 20))
plt.subplot(2, 2, 1)
plt.titel("Original")
plt.imshow(Bild)
# Graustufen
grau = cv2.cvtColor(Bild,cv2.COLOR_BGR2GRAY)
# Canny Kanten
kantig = cv2.Canny(grau, 30, 200)
plt.subplot(2, 2, 2)
plt.titel("Canny Edges")
plt.imshow(kantig)
# Konturen finden
Kontur, hier = cv2.findContours(kantig, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
plt.subplot(2, 2, 3)
plt.imshow(kantig)
drucken("Anzahl der Konturen = " + str(len(Kontur)))
# Alle Konturen
cv2.drawContours(Bild, Konturen, -1, (0,255,0), 3)
plt.subplot(2, 2, 4)
plt.titel("Konturen")
plt.imshow(Bild)
Linienerkennung mit harten Linien
Linien können in einem Bild mithilfe von Hough-Linien erkannt werden. OpenCV bietet eine HouhLines-Funktion bei dem der Schwellenwert passieren soll. Der Schwellenwert ist die Mindeststimme, damit eine Linie berücksichtigt wird. Für eine ausführliche Beschreibung, eine vollständige Implementierung finden Sie im folgenden Code. Zur Linienerkennung mit Hough-Linien in OpenCV. Für mehr Informationen, Sieh dir das an Verknüpfung.
# Bild laden
image = cv2.imread('sudoku.png')
image = cv2.cvtColor(Bild, cv2.COLOR_BGR2RGB)
plt.figur(Feigengröße=(20, 20))
# Graustufen
grau = cv2.cvtColor(Bild, cv2.COLOR_BGR2GRAY)
# Canny Edges
Kanten = cv2.Canny(grau, 100, 170, Blendengröße = 3)
plt.subplot(2, 2, 1)
plt.titel("Kanten")
plt.imshow(Kanten)
# HoughLines-Funktion ausführen
Linien = cv2.HoughLines(Kanten, 1, np.pi/180, 200)
# Für Schleife durch jede Zeile laufen
für Zeile in Zeile:
rho, theta = Linie[0]
a = np.cos(theta)
b = np.sin(theta)
x0 = a * rho
y0 = b * rho
x_1 = int(x0 + 1000 * (-B))
y_1 = int(y0 + 1000 * (ein))
x_2 = int(x0 - 1000 * (-B))
y_2 = int(y0 - 1000 * (ein))
cv2.line(Bild, (x_1, y_1), (x_2, y_2), (255, 0, 0), 2)
# Endgültige Ausgabe anzeigen
plt.subplot(2, 2, 2)
plt.imshow(Bild)
Ecken finden
So finden Sie die Ecken eines Bildes, benutze el CornerHarris-Funktion von OpenCV. Für eine detaillierte Übersicht, siehe den Code unten für eine vollständige Implementierung, um Ecken mit OpenCV zu finden. Für mehr Informationen, Sieh dir das an Verknüpfung.
# Bild laden
image = cv2.imread('chessboard.png')
# Graustufen
image = cv2.cvtColor(Bild, cv2.COLOR_BGR2RGB)
plt.figur(Feigengröße=(10, 10))
grau = cv2.cvtColor(Bild, cv2.COLOR_BGR2GRAY)
# CornerHarris-Funktion möchte, dass die Eingabe float ist
grau = np.float32(grau)
h_corners = cv2.cornerHarris(grau, 3, 3, 0.05)
Kernel = np.ones((7,7),z.B. uint8)
h_corners = cv2.dilate(harris_corners, Kernel, Iterationen = 10)
Bild[h_ecken > 0.024 * h_corners.max() ] = [256, 128, 128]
plt.subplot(1, 1, 1)
# Endgültige Ausgabe
plt.imshow(Bild)
Kreise und Ellipsen zählen
Kreise und Ellipsen zählen auf einem bild, benutze el SimpleBlobDetector-Funktion von OpenCV. Für eine detaillierte Übersicht, Siehe Code unten für die vollständige Implementierung von Kreisen und Ellipsen zählen in einem Bild mit OpenCV. Für mehr Informationen, Sieh dir das an Verknüpfung.
# Bild laden
image = cv2.imread('blobs.jpg')
image = cv2.cvtColor(Bild, cv2.COLOR_BGR2RGB)
plt.figur(Feigengröße=(20, 20))
Detektor = cv2.SimpleBlobDetector_create()
# Blobs erkennen
Punkte = Detektor.detect(Bild)
leer = np.null((1,1))
blobs = cv2.drawKeypoints(Bild, Punkte, leer, (0,0,255),
cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
number_of_blobs = len(Schlüsselpunkte)
Text = "Blobs insgesamt: " + str(len(Schlüsselpunkte))
cv2.putText(Kleckse, Text, (20, 550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100, 0, 255), 2)
plt.subplot(2, 2, 1)
plt.imshow(Kleckse)
# Filterparameter
# Parametereinstellung mit cv2.SimpleBlobDetector initialisieren
params = cv2.SimpleBlobDetector_Params()
# Bereichsfilterungsparameter
params.filterByArea = True
params.minArea = 100
# Parameter für die Kreisförmigkeitsfilterung
params.filterByCircularity = True
params.minCircularity = 0.9
# Konvexitätsfilterparameter
params.filterByConvexity = False
params.minKonvexität = 0.2
# Parameter für die Trägheitsfilterung
params.filterByInertia = True
params.minInertiaRatio = 0.01
# Detektor mit den Parametern
Detektor = cv2.SimpleBlobDetector_create(Parameter)
# Blobs erkennen
Schlüsselpunkte = Detector.detect(Bild)
# Zeichnen Sie Kleckse als rote Kreise auf unser Bild
leer = np.null((1,1))
blobs = cv2.drawKeypoints(Bild, Schlüsselpunkte, leer, (0,255,0),
cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
number_of_blobs = len(Schlüsselpunkte)
Text = "Nein. Kreisförmige Kleckse: " + str(len(Schlüsselpunkte))
cv2.putText(Kleckse, Text, (20, 550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 100, 255), 2)
# Blobs anzeigen
plt.subplot(2, 2, 2)
plt.titel("Nur kreisförmige Blobs filtern")
plt.imshow(Kleckse)
Abschließende Anmerkungen
Dann, In diesem Artikel, wir hatten ein ausführliches Gespräch über Bildbearbeitung mit OpenCV. Ich hoffe, Sie lernen etwas aus diesem Blog und helfen Ihnen in Zukunft. Danke fürs Lesen und deine Geduld. Viel Glück!
Sie können meine Artikel hier einsehen: Artikel
E-Mail-Identifikation: [E-Mail geschützt]
Verbinden Sie sich mit mir auf LinkedIn: LinkedIn
Die in diesem OpenCV-Bildverarbeitungsartikel gezeigten Medien sind nicht Eigentum von DataPeaker und werden nach Ermessen des Autors verwendet.
