Bildsegmentierung mit opencv

In den vorherigen Tutorials haben wir OpenCV für die grundlegende Bildverarbeitung verwendet und einige erweiterte Bildbearbeitungsvorgänge durchgeführt. Wie wir wissen, ist OpenCV eine Open Source Commuter Vision Library mit C ++ -, Python- und Java-Schnittstellen, die Windows, Linux, Mac OS, iOS und Android unterstützt. So kann es einfach in Raspberry Pi mit Python- und Linux-Umgebung installiert werden. Mit Raspberry Pi mit OpenCV und angeschlossener Kamera können viele Echtzeit-Bildverarbeitungsanwendungen wie Gesichtserkennung, Gesichtsverriegelung, Objektverfolgung, Autokennzeichenerkennung, Haussicherungssystem usw. erstellt werden. In diesem Tutorial erfahren Sie, wie das geht Bildsegmentierung mit OpenCV. Die Operationen, die wir ausführen werden, sind unten aufgeführt:

• Segmentierung und Konturen
• Hierarchie- und Abrufmodus
• Annäherung an Konturen und Auffinden ihrer konvexen Hülle
• Conex Rumpf
• Passende Kontur
• Formen identifizieren (Kreis, Rechteck, Dreieck, Quadrat, Stern)
• Linienerkennung
• Blob-Erkennung
• Filtern der Blobs - Zählen von Kreisen und Ellipsen

1. Segmentierung und Konturen

Die Bildsegmentierung ist ein Prozess, bei dem wir Bilder in verschiedene Regionen unterteilen. Während die Konturen die durchgehenden Linien oder Kurven sind, die die gesamte Grenze eines Objekts in einem Bild begrenzen oder abdecken. Und hier verwenden wir die Bildsegmentierungstechnik, die als Konturen bezeichnet wird, um die Teile eines Bildes zu extrahieren.

Auch Konturen sind in sehr wichtig

• Objekterkennung
• Formanalyse

Und sie haben ein sehr breites Anwendungsfeld von der realen Bildanalyse bis zur medizinischen Bildanalyse wie bei MRTs

Lassen Sie uns wissen, wie Konturen in opencv implementiert werden, indem Konturen von Quadraten extrahiert werden.

import cv2 import numpy as np

Laden wir ein einfaches Bild mit 3 schwarzen Quadraten

image = cv2.imread ('squares.jpg') cv2.imshow ('Eingabebild', Bild) cv2.waitKey (0)

Graustufen

grau = cv2.cvtColor (Bild, cv2.COLOR_BGR2GRAY)

Finden Sie schlaue Kanten

kantig = cv2.Canny (grau, 30.200) cv2.imshow ('schlaue Kanten', kantig) cv2.waitKey (0)

Konturen finden

#Verwenden Sie eine Kopie Ihres Bildes, z. B. - edged.copy (), da das Finden von Konturen das Bild ändert. # Wir müssen _ vor den Konturen als leeres Argument hinzufügen, da die OpenCV-Version _ aktualisiert wurde. Konturen, Hierarchie = cv2.findContours (kantig, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('schlaue Kanten nach Konturierung', kantig) cv2.waitKey (0)

Drucken der Konturdatei, um zu wissen, woraus Konturen bestehen

print (Konturen) print ('Anzahl der gefundenen Konturen =' + str (len (Konturen)))

Zeichnen Sie alle Konturen

#Verwenden Sie -1 als dritten Parameter, um alle Konturen zu zeichnen. cv2.drawContours (Bild, Konturen, -1, (0,255,0), 3) cv2.imshow ('Konturen', Bild) cv2.waitKey (0) cv2. destroyAllWindows ()

Konsolenausgabe -],],], …,],],]], dtype = int32), array (],],

], …,

],],]], dtype = int32), array (],],], …,],],]], dtype = int32)]

Anzahl der gefundenen Konturen = 3. Wir haben also insgesamt drei Konturen gefunden.

Im obigen Code, mit dem wir auch die Konturdatei gedruckt haben , zeigt diese Datei, wie diese Konturen aussehen, wie in der obigen Konsolenausgabe dargestellt.

In der obigen Konsolenausgabe haben wir eine Matrix, die wie Koordinaten von x, y Punkten aussieht. OpenCV speichert Konturen in Listen von Listen. Wir können die obige Konsolenausgabe einfach wie folgt anzeigen:

KONTUR 1 KONTUR 2 KONTUR 3

], array (], array (],],],],],],],

…,…,…,],],],],],],]], dtype = int32),]], dtype = int32),]], dtype = int32)]

Wenn wir nun die Längenfunktion für Konturdateien verwenden, erhalten wir eine Länge von 3, was bedeutet, dass diese Liste drei Listen von Listen enthält, dh drei Konturen.

Stellen Sie sich nun vor, CONTOUR 1 ist das erste Element in diesem Array und diese Liste enthält eine Liste aller Koordinaten. Diese Koordinaten sind die Punkte entlang der Konturen, die wir gerade als grüne rechteckige Kästchen gesehen haben.

Es gibt verschiedene Methoden zum Speichern dieser Koordinaten, die als Approximationsmethoden bezeichnet werden. Grundsätzlich gibt es zwei Arten von Approximationsmethoden

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE speichert alle Grenzpunkte, aber wir benötigen nicht unbedingt alle Grenzpunkte. Wenn der Punkt eine gerade Linie bildet, benötigen wir nur den Startpunkt und den Endpunkt auf dieser Linie.

cv2.CHAIN_APPROX_SIMPLE stellt stattdessen nur die Start- und Endpunkte der Begrenzungskonturen bereit. Das Ergebnis ist eine wesentlich effizientere Speicherung von Konturinformationen.

_, Konturen, Hierarchie = cv2.findContours (kantig, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

Im obigen Code ist cv2.RETR_EXTERNAL der Abrufmodus, während cv2.CHAIN_APPROX_NONE ist

die Approximationsmethode.

Wir haben also etwas über Konturen und Approximationsmethoden gelernt. Lassen Sie uns nun die Hierarchie und den Abrufmodus untersuchen.

2. Hierarchie- und Abrufmodus

Der Abrufmodus definiert die Hierarchie in Konturen wie Unterkonturen oder Außenkonturen oder allen Konturen.

Jetzt gibt es vier Abrufmodi, die nach Hierarchietypen sortiert sind.

cv2.RETR_LIST - Ruft alle Konturen ab.

cv2.RETR_EXTERNAL - Ruft nur externe oder äußere Konturen ab.

cv2.RETR_CCOMP - Ruft alle in einer 2-Ebenen-Hierarchie ab.

cv2.RETR_TREE - Ruft alle in einer vollständigen Hierarchie ab.

Die Hierarchie wird im folgenden Format gespeichert

Lassen Sie uns nun den Unterschied zwischen den ersten beiden Abrufmodi cv2.RETR_LIST und cv2.RETR_EXTERNAL veranschaulichen.

import cv2 import numpy as np

Laden wir ein einfaches Bild mit 3 schwarzen Quadraten

image = cv2.imread ('square donut.jpg') cv2.imshow ('Eingabebild', Bild) cv2.waitKey (0)

Graustufen

grau = cv2.cvtColor (Bild, cv2.COLOR_BGR2GRAY)

Finden Sie Canny Edges

kantig = cv2.Canny (grau, 30.200) cv2.imshow ('schlaue Kanten', kantig) cv2.waitKey (0)

Konturen finden

#Verwenden Sie eine Kopie Ihres Bildes, z. B. - edged.copy (), da das Finden von Konturen das Bild ändert. # Wir müssen _ vor den Konturen als leeres Argument hinzufügen, da die offene Lebenslaufversion _, Konturen, Hierarchie = aktualisiert wurde cv2.findContours (kantig, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('schlaue Kanten nach Konturierung', kantig) cv2.waitKey (0)

Drucken der Konturdatei, um zu wissen, woraus Konturen bestehen.

print (Konturen) print ('Anzahl der gefundenen Konturen =' + str (len (Konturen)))

Zeichnen Sie alle Konturen

#Verwenden Sie -1 als dritten Parameter, um alle Konturen zu zeichnen. cv2.drawContours (Bild, Konturen, -1, (0,255,0), 3) cv2.imshow ('Konturen', Bild) cv2.waitKey (0) cv2. destroyAllWindows

import cv2 import numpy as np

Laden wir ein einfaches Bild mit 3 schwarzen Quadraten

image = cv2.imread ('square donut.jpg') cv2.imshow ('Eingabebild', Bild) cv2.waitKey (0)

Graustufen

grau = cv2.cvtColor (Bild, cv2.COLOR_BGR2GRAY)

Finden Sie schlaue Kanten

kantig = cv2.Canny (grau, 30.200) cv2.imshow ('schlaue Kanten', kantig) cv2.waitKey (0)

Konturen finden

#Verwenden Sie eine Kopie Ihres Bildes, z. B. - edged.copy (), da das Finden von Konturen das Bild ändert. # Wir müssen _ vor den Konturen als leeres Argument hinzufügen, da die offene Lebenslaufversion _ aktualisiert wurde. Konturen, Hierarchie = cv2.findContours (kantig, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ('schlaue Kanten nach Konturierung', kantig) cv2.waitKey (0)

Drucken der Konturdatei, um zu wissen, woraus Konturen bestehen.

print (Konturen) print ('Anzahl der gefundenen Konturen =' + str (len (Konturen)))

Zeichnen Sie alle Konturen

#Verwenden Sie -1 als dritten Parameter, um alle Konturen zu zeichnen. cv2.drawContours (Bild, Konturen, -1, (0,255,0), 3) cv2.imshow ('Konturen', Bild) cv2.waitKey (0) cv2. destroyAllWindows ()

Durch die Demonstration der obigen Codes konnten wir den Unterschied zwischen cv2.RETR_LIST und cv2.RETR_EXTERNNAL deutlich erkennen. In cv2.RETR_EXTERNNAL werden nur die äußeren Konturen berücksichtigt, während die inneren Konturen ignoriert werden.

In cv2.RETR_LIST werden auch innere Konturen berücksichtigt.

3. Annäherung der Konturen und Auffinden der konvexen Hülle

Bei der Approximation von Konturen wird eine Konturform über eine andere Konturform approximiert, die der ersten Konturform möglicherweise nicht so ähnlich ist.

Zur Annäherung verwenden wir die approxPolyDP- Funktion von openCV, die unten erläutert wird

cv2.approxPolyDP (Kontur, Approximationsgenauigkeit, geschlossen)

Parameter:

• Kontur - ist die individuelle Kontur, die wir approximieren möchten.
• Approximationsgenauigkeit - wichtiger Parameter bei der Bestimmung der Approximationsgenauigkeit, kleiner Wert liefert präzise Approximation, große Werte liefern allgemeinere Informationen. Eine gute Daumenregel ist weniger als 5% des Konturumfangs.
• Geschlossen - Ein boolescher Wert, der angibt, ob die ungefähre Kontur offen oder geschlossen sein kann.

Versuchen wir, eine einfache Figur eines Hauses zu approximieren

import numpy als np import cv2

Laden Sie das Bild und bewahren Sie eine Kopie auf

image = cv2.imread ('house.jpg') orig_image = image.copy () cv2.imshow ('Originalbild', orig_image) cv2.waitKey (0)

Graustufen und binärisieren Sie das Bild

grau = cv2.cvtColor (Bild, cv2.COLOR_BGR2GRAY) ret, Thresh = cv2.threshold (grau, 127.255, cv2.THRESH_BINARY_INV)

Konturen finden

_, Konturen, Hierarchie = cv2.findContours (Thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Durchlaufen Sie jede Kontur und berechnen Sie ihr Begrenzungsrechteck

für c in Konturen: x, y, w, h = cv2.boundingRect (c) cv2.rectangle (orig_image, (x, y), (x + w, y + h), (0,0,255), 2) cv2.imshow ('Bounding rect', orig_image) cv2.waitKey (0)

Durchlaufen Sie jede Kontur und berechnen Sie die ungefähre Kontur

für c in Konturen:

# Berechnen Sie die Genauigkeit als Prozent der Genauigkeit des Konturumfangs = 0,03 * cv2.arcLength (c, True) ca. = cv2.approxPolyDP (c, Genauigkeit, True) cv2.drawContours (Bild,, 0, (0,255,0), 2) cv2.imshow ('Ungefähres PolyDP', Bild) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Konvexer Rumpf

Konvexe Hülle ist im Grunde die Außenkante, dargestellt durch Zeichnen von Linien über eine bestimmte Figur.

Es könnte das kleinste Polygon sein, das um das Objekt selbst passen kann.

cv2 importieren numpy importieren als np image = cv2.imread ('star.jpg') grey = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) cv2.imshow ('original image', image) cv2.waitKey (0)

Schwelle das Bild

ret, thresh = cv2.threshold (grau, 176,255,0)

Konturen finden

_, Konturen, Hierarchie = cv2.findContours (Thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Sortieren Sie die Konturen nach Fläche und entfernen Sie dann die größte Rahmenkontur

n = len (Konturen) -1 Konturen = sortiert (Konturen, Schlüssel = cv2.contourArea, reverse = False)

Durch die Konturen iterieren und konvexen Rumpf zeichnen

für c in Konturen:

hull = cv2.convexHull (c) cv2.drawContours (Bild,, 0, (0,255,0), 2) cv2.imshow ('konvexe Hülle', Bild) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Kontur nach Formen anpassen

cv2.matchShapes (Konturvorlage, Konturmethode, Methodenparameter)

Ausgabe - Übereinstimmungswert (niedrigerer Wert bedeutet eine engere Übereinstimmung)

Konturvorlage - Dies ist unsere Referenzkontur, die wir in einem neuen Bild suchen möchten.

Kontur - Die individuelle Kontur, gegen die wir prüfen.

Methode - Art der Konturanpassung (1,2,3).

Methodenparameter - lassen Sie als 0.0 in Ruhe (wird in Python opencv nicht verwendet)

import cv2 import numpy as np

Laden Sie die Formvorlage oder das Referenzbild

template = cv2.imread ('star.jpg', 0) cv2.imshow ('template', template) cv2.waitKey (0)

Laden Sie das Zielbild mit den Formen, die wir abgleichen möchten

target = cv2.imread ('shapeestomatch.jpg') grey = cv2.cvtColor (target, cv2.COLOR_BGR2GRAY)

Schwellen Sie beide Bilder zuerst, bevor Sie cv2.findContours verwenden

ret, Schwelle1 = cv2.threshold (Vorlage, 127.255,0) ret, Schwelle2 = cv2.threshold (grau, 127.255,0)

Finden Sie Konturen in der Vorlage

_, contours, hierarhy = cv2.findContours (Thresh1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) # Wir müssen die Konturen nach Fläche sortieren, damit wir die größte Kontur entfernen können

Bildumriss

sortiert_contours = sortiert (Konturen, Schlüssel = cv2.contourArea, umgekehrt = Wahr) #Wir extrahieren die zweitgrößte Kontur, die unsere Vorlage sein wird. Kontur tempelate_contour = Konturen #extrahieren Sie die Konturen aus dem zweiten Zielbild _, Konturen, Hierarchie = cv2.findContours (Thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) für c in Konturen: # Durch jede Kontur im Zielbild iterieren und mit cv2.matchShape die Konturform vergleichen match = cv2.matchShapes (tempelate_contour, c, 1,0.0) print ("Übereinstimmung") #wenn der Übereinstimmungswert kleiner als 0,15 ist, wenn Übereinstimmung <0,16: nächstgelegene_Kontur = c sonst: nächstgelegene_Kontur = cv2.drawContours (Ziel,, - 1, (0,255,0), 3) cv2.imshow ('Ausgabe',Ziel) cv2.waitKey (0) cv2.destroyAllWindows ()

Konsolenausgabe -

0,16818605122199104

0.19946910256158912

0,18949760627309664

0,11101058276281539

Es gibt drei verschiedene Methoden mit unterschiedlichen mathematischen Funktionen. Wir können mit jeder Methode experimentieren, indem wir einfach die Methodenwerte von cv2.matchShapes (tempelate_contour, c, 1, 0.0) ersetzen, die zwischen 1,2 und 3 variieren. Für jeden Wert erhalten Sie unterschiedliche Übereinstimmungen Werte in der Konsolenausgabe.

6. Formen identifizieren (Kreis, Rechteck, Dreieck, Quadrat, Stern)

OpenCV kann auch verwendet werden, um verschiedene Arten von Formen automatisch aus dem Bild zu erkennen. Mit dem folgenden Code können wir Kreise, Rechtecke, Dreiecke, Quadrate und Sterne aus dem Bild erkennen.

import cv2 import numpy as np

Laden und dann Graustufenbilder

image = cv2.imread ('shape.jpg') grey = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) cv2.imshow ('Formen identifizieren', image) cv2.waitKey (0) ret, thresh = cv2.threshold (grey 127, 255,1)

Konturen extrahieren

_, Konturen, Hierarchie = cv2.findContours (Thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Für cnt in Konturen:

Erhalten Sie ungefähre Polygone ca. = cv2.approxPolyDP (cnt, 0.01 * cv2.arcLength (cnt, True), True), wenn len (ungefähr) == 3: shape_name = "Triangle" cv2.drawContours (image,, 0, (0,255, 0), - 1)

Suchen Sie die Konturmitte, um Text in der Mitte zu platzieren

M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (Bild, Formname, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0), 0), 1) elif len (ungefähr) == 4: x, y, w, h = cv2.boundingRect (cnt) M = cv2.moments (cnt) cx = int (M / M) cy = int (M. / M)

Überprüfen Sie, ob das vierseitige Polygon quadratisch oder rechteckig ist

# cv2.boundingRect gibt die linke Breite und Höhe in Pixel zurück, beginnend mit der oberen # linken Ecke. Für ein Quadrat wäre es ungefähr dasselbe, wenn abs (wh) <= 3: shape_name = "square" # Konturmitte finden, um Text zu platzieren center cv2.drawContours (Bild,, 0, (0,125,255), - 1) cv2.putText (Bild, Formname, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) sonst: shape_name = "Reactangle" #Konturmitte finden, um Text in der Mitte zu platzieren cv2.drawContours (Bild,, 0, (0,0,255), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (Bild, Formname, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (ungefähr) == 10: Formname = 'Star' cv2.drawContours (Bild,, 0, (255,255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (Bild, Formname, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (ungefähr)> = 15: shape_name = 'circle' cv2.drawContours (image,, 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (Bild, Formname, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ('Formen identifizieren', Bild) cv2.waitKey (0) cv2.destroyAllWindows ()

7. Linienerkennung

Die Linienerkennung ist in OpenCV ein sehr wichtiges Konzept und wird in der realen Welt vielversprechend eingesetzt. Autonome Autos verwenden Linienerkennungsalgorithmen zur Erkennung von Fahrspuren und Straßen.

Bei der Linienerkennung werden wir uns mit zwei Algorithmen befassen:

• Hough-Line-Algorithmus
• Probalistischer Hough-Line-Algorithmus.

Möglicherweise haben Sie sich an die Darstellung der Linie aus der Mathematik der High School mit der Gleichung y = mx + c erinnert.

In OpenCV wird die Zeile jedoch auf andere Weise dargestellt

Die obige Gleichung ρ = xcosӨ + ysincosӨ ist die OpenCV-Darstellung der Linie, wobei ρ der senkrechte Abstand der Linie vom Ursprung ist und Ө der Winkel ist, der durch die Normale dieser Linie zum Ursprung gebildet wird (gemessen im Bogenmaß, wobei 1 pi Radiant / 180 = 1 Grad).

Die OpenCV-Funktion zur Linienerkennung ist gegeben als

cv2.HoughLines (binärisiertes Bild, ρ Genauigkeit, Ө Genauigkeit, Schwellenwert), wobei der Schwellenwert die Mindestabstimmung ist, damit er als Linie betrachtet wird.

Lassen Sie uns nun mit Hilfe der Hough-Linienfunktion von opencv Linien für ein Boxbild erkennen.

import cv2 import numpy as np image = cv2.imread ('box.jpg')

Graustufen- und Knallkanten extrahiert

grau = cv2.cvtColor (Bild, cv2.COLOR_BGR2GRAY) Kanten = cv2.Canny (grau, 100.170, ApertureSize = 3)

Führen Sie Hough-Linien mit einer Rho-Genauigkeit von 1 Pixel aus

Die # Theta-Genauigkeit von (np.pi / 180), die 1 Grad # Linienschwelle ist, wird auf 240 (Anzahl der Punkte auf der Linie) eingestellt. Linien = cv2.HoughLines (Kanten, 1, np.pi / 180, 240) # Wir iterieren durch jede Zeile und konvertieren Sie in das Format #, das von cv2.lines (dh Endpunkte erforderlich) für i im Bereich (0, len (Zeilen)) benötigt wird: für rho Theta in Zeilen: a = np.cos (Theta) b = np.sin (Theta) x0 = a * rho y0 = b * rho x1 = int (x0 + 1000 * (- b)) y1 = int (y0 + 1000 * (a)) x2 = int (x0-1000 * (-b)) y2 = int (y0-1000 * (a)) cv2.line (Bild, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('hough lines', Bild) cv2.waitKey (0) cv2.destroyAllWindows ()

Wiederholen wir nun die obige Linienerkennung mit einem anderen Algorithmus der probabilistischen Hough-Linie.

Die Idee hinter der probabilistischen Hough-Linie besteht darin, eine zufällige Teilmenge von Punkten zu nehmen, die für die Linienerkennung ausreicht.

Die OpenCV-Funktion für die probabilistische Hough-Linie wird als cv2 dargestellt. HoughLinesP (binärisiertes Bild, ρ Genauigkeit, Ө Genauigkeit, Schwellenwert, minimale Linienlänge, maximale Linienlücke)

Lassen Sie uns nun Boxlinien mit Hilfe probabilistischer Hough-Linien erkennen.

import cv2 import numpy as np

Graustufen- und Knallkanten extrahiert

image = cv2.imread ('box.jpg') grey = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) Kanten = cv2.Canny (grey, 50.150, apertureSize = 3) #wieder verwenden wir jedoch die gleichen Rho- und Theta-Genauigkeiten wir eine Mindest Stimme (pts entlang Linie) von 100 angeben #und min Linienlänge von 5 Pixeln und max Spalte zwischen den Zeilen von 10 Pixeln Zeilen = cv2.HoughLinesP (Kanten, 1, np.pi / 180,100,100,10) für i im Bereich (0, len (Linien)): für x1, y1, x2, y2 in Linien: cv2.line (Bild, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('probalistic hough lines', Bild) cv2.waitKey (0) cv2.destroyAllWindows

8. Blob-Erkennung

Blobs können als eine Gruppe verbundener Pixel beschrieben werden, die alle eine gemeinsame Eigenschaft haben. Die Methode zur Verwendung des OpenCV-Blob-Detektors wird in diesem Flussdiagramm beschrieben.

Zum Zeichnen der wichtigsten Punkte verwenden wir cv2.drawKeypoints, das die folgenden Argumente verwendet.

cv2.drawKeypoints (Eingabebild, Schlüsselpunkte, blank_output_array, Farbe, Flags)

wo in den Fahnen sein könnte

cv2.DRAW_MATCHES_FLAGS_DEFAULT

cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS

cv2.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG

cv2.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS

und leer ist hier so ziemlich nichts als eine nach der anderen Matrix von Nullen

Lassen Sie uns nun die Blob-Erkennung an einem Bild von Sonnenblumen durchführen, wobei die Blobs die zentralen Teile der Blume darstellen, da sie allen Blumen gemeinsam sind.

import cv2 import numpy as np image = cv2.imread ('Sunflowers.jpg', cv2.IMREAD_GRAYSCALE)

Richten Sie den Detektor mit den Standardparametern ein

detector = cv2.SimpleBlobDetector_create ()

Blobs erkennen

Schlüsselpunkte = detector.detect (Bild)

Zeichnen Sie erkannte Blobs als rote Kreise

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS stellen sicher, dass die # Größe des Kreises der Größe des Blob- Leerzeichens entspricht = np.zeros ((1,1) )

Schlüsselpunkte anzeigen

cv2.imshow ('Blobs', Blobs) cv2.waitKey (0) cv2.destroyAllWindows ()

Obwohl der Code gut funktioniert, werden einige der Blobs aufgrund ungleichmäßiger Blumengrößen übersehen, da die Blumen auf der Vorderseite im Vergleich zu den Blumen am Ende groß sind.

9. Filtern der Blobs - Zählen von Kreisen und Ellipsen

Wir können Parameter verwenden, um die Blobs nach ihrer Form, Größe und Farbe zu filtern. Für die Verwendung von Parametern mit Blob-Detektor verwenden wir die OpenCV-Funktion

cv2.SimpleBlobDetector_Params ()

Wir werden sehen, wie die Blobs hauptsächlich nach diesen vier unten aufgeführten Parametern gefiltert werden:

Bereich

params.filterByArea = Richtig / Falsch params.minArea = Pixel params.maxArea = Pixel

Zirkularität

params.filterByCircularity = Richtig / Falsch params.minCircularity = 1 ist perfekt, 0 ist entgegengesetzt

Konvexität - Bereich des Blobs / Bereich der konvexen Hülle

params.filterByConvexity = Richtig / Falsch params.minConvexity = Bereich

Trägheit

params.filterByInertia = Richtig / Falsch params.minInertiaRatio = 0.01

Versuchen wir nun, Blobs nach den oben genannten Parametern zu filtern

importiere cv2 importiere numpy als np image = cv2.imread ('blobs.jpg') cv2.imshow ('original image', image) cv2.waitKey (0)

Initialisieren Sie den Detektor mit Standardparametern

detector = cv2.SimpleBlobDetector_create ()

Blobs erkennen

Schlüsselpunkte = detector.detect (Bild)

Zeichnen Sie Blobs als rote Kreise auf unser Bild

leer = np.zeros ((1,1)) blobs = cv2.drawKeypoints (Bild, Schlüsselpunkte, leer, (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) Anzahl_der_Blobs = len (Schlüsselpunkte) text = "Gesamtzahl der Blobs" + str (len (Schlüsselpunkte)) cv2.putText (Blobs, Text, (20.550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0,255), 2)

Bild mit Blob-Schlüsselpunkten anzeigen

cv2.imshow ('Blob mit Standardparametern', Blobs) cv2.waitKey (0)

Stellen Sie unsere Filterparameter ein

# Parametereinstellung mit cv2.SimpleBlobDetector params initialisieren = cv2.SimpleBlobDetector_Params ()

Stellen Sie die Parameter für die Bereichsfilterung ein

params.filterByArea = True params.minArea = 100

Stellen Sie die Filterparameter für die Zirkularität ein

params.filterByCircularity = True params.minCircularity = 0.9

Stellen Sie den Konvexitätsfilterparameter ein

params.filterByConvexity = False params.minConvexity = 0.2

Stellen Sie den Trägheitsfilterparameter ein

params.filterByInertia = True params.minInertiaRatio = 0.01

Detektor mit Parameter erstellen

detector = cv2.SimpleBlobDetector_create (params)

Blobs erkennen

Schlüsselpunkte = detector.detect (Bild)

Zeichnen Sie Blobs als rote Kreise auf die Bilder

leer = np.zeros ((1,1)) blobs = cv2.drawKeypoints (Bild, Schlüsselpunkte, leer, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) Anzahl_der_blobs = len (Schlüsselpunkte) text = "Gesamtzahl der kreisförmigen Blobs" + str (len (Schlüsselpunkte)) cv2.putText (Blobs, Text, (20.550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0.100.255), 2)

Blobs anzeigen

cv2.imshow ('Filtering Circular Blobs', Blobs) cv2.waitKey (0) cv2.destroyAllWindows ()

So kann die Bildsegmentierung in Python-OpenCV durchgeführt werden. Um Computer Vision und OpenCV besser zu verstehen, lesen Sie die vorherigen Artikel (Erste Schritte mit Python OpenCV und Bildmanipulationen in Python OpenCV, und Sie können mit Computer Vision etwas Cooles machen.