Bildmanipulationen in opencv (Teil

In den vorherigen Tutorials haben wir uns mit OpenCV vertraut gemacht und einige grundlegende Bildverarbeitungen durchgeführt. Im nächsten Tutorial haben wir einige Bildmanipulationen in OpenCV durchgeführt, z. B. Zuschneiden, Drehen, Bildtransformation usw. In Fortsetzung des vorherigen Tutorials zur Bildmanipulation lernen wir hier Einige weitere Bildbearbeitungstechniken wie und am Ende des Tutorials werden wir ein Python-OpenCV-Programm erstellen, um eine Live-Skizze aus dem Webcam-Live-Feed zu erstellen. Diese Anwendung verwendet viele der Bildverarbeitungsfunktionen, die wir bisher gelernt haben oder die wir in diesem Tutorial lernen werden. Dies ist also ein gutes praktisches Beispiel, um alle Funktionen abzudecken.

Wie im vorherigen Tutorial beschrieben, ist OpenCV eine Open Source Commuter Vision Library, die über C ++ -, Python- und Java-Schnittstellen verfügt und 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, Erkennung von Autokennzeichen, Haussicherungssystem usw. erstellt werden.

In diesem Tutorial werden wir einige weitere Bildmanipulationen mit Python OpenCV sehen. Hier lernen wir, die folgende Funktion mit Python OpenCV auf ein Bild anzuwenden:

• Bitweise Operationen und Maskierung
• Faltung & Unschärfe
• Schärfen - Umkehren der Bildunschärfen
• Schwellenwert (Binarisierung)
• Dilatation, Erosion, Öffnen / Schließen
• Kantenerkennung und Bildverläufe
• Perspektive & Affine Transformation
• Live-Skizzenanwendung

1. Bitweise Operationen und Maskierung

Bitweise Operationen helfen Ihnen bei der Bildmaskierung und beim Erstellen einiger einfacher Bilder.

Ein Quadrat machen

import cv2 import numpy as np # Wir verwenden nur zwei Dimensionen, da dies ein Graustufenbild ist. Wenn wir ein # farbiges Bild verwenden, haben wir ein Rechteck verwendet = np.zeros ((300,300,3), np.uint8) # Erstellen eines quadratischen Quadrats = np.zeros ((300.300), np.uint8) cv2.rectangle (Quadrat, (50,50), (250.250), 255, -1) cv2.imshow ("Quadrat", Quadrat) cv2. waitKey (0)

Eine Ellipse machen

Ellipse = np.zeros ((300.300), np.uint8) cv2.ellipse (Ellipse, (150.150), (150.150), 30.0.180.255, -1) cv2.imshow ("Ellipse", Ellipse) cv2.waitKey (0)

Experimentieren mit bitweisen Operationen

#AND_ zeigt nur, wo sich die beiden schneiden

BitwiseAND = cv2.bitwise_and (Quadrat, Ellipse) cv2.imshow ("AND", BitwiseAND) cv2.waitKey (0)

#OR_ zeigt nur an, wo sich entweder ein Quadrat oder eine Ellipse befindet

BitwiseOR = cv2.bitwise_or (Quadrat, Ellipse) cv2.imshow ("OR", BitwiseOR) cv2.waitKey (0)

#XOR_ zeigt nur an, wo eines für sich existiert

BitwiseXOR = cv2.bitwise_xor (Quadrat, Ellipse) cv2.imshow ("XOR", BitwiseXOR) cv2.waitKey (0)

#NOT_shows alles, was nicht Teil der Ellipse und der NOT-Operation ist, kann nur auf eine einzelne Figur angewendet werden

BitwiseNOT_elp = cv2.bitwise_not (Ellipse) cv2.imshow ("NOT_ellipse", BitwiseNOT_elp) cv2.waitKey (0) cv2.destroyAllWindows ()

2. Faltung & Unschärfe

Eine Faltung ist eine mathematische Operation, die an zwei Funktionen ausgeführt wird und eine dritte Funktion erzeugt, die typischerweise eine modifizierte Version der ursprünglichen Funktion ist.

Ausgabebild = Bildfunktion _{Kernelgröße}

In der Computer Vision verwenden wir Kernel, um die Größe anzugeben, über die wir unsere Manipulationsfunktion über unser Bild ausführen.

Unschärfe ist eine Operation, bei der die Pixel innerhalb einer Region (Kernel) gemittelt werden.

OpenCV verwischt ein Bild durch Anwenden von Kerneln. Ein Kernel zeigt Ihnen, wie Sie den Wert eines bestimmten Pixels ändern können, indem Sie ihn mit einer unterschiedlichen Anzahl benachbarter Pixel kombinieren. Der Kernel wird nacheinander auf jedes Pixel im Bild angewendet, um das endgültige Bild zu erzeugen.

Einfach gesagt, eine Bildfaltung ist einfach eine elementweise Multiplikation zweier Matrizen, gefolgt von einer Summe.

Wir können es einfach anhand des folgenden Beispiels verstehen.

Das Obige ist ein 3X3-Kernel.

Wir multiplizieren mit 1/25, um die Summe auf 1 zu normalisieren. Wir haben die Intensität erhöht oder verringert, wie im Fall der Aufhellung oder Verdunkelung von Bildern.

Testen wir eine opencv-Unschärfemethode filter2D, die durch die Funktion cv2.filter2D (image, -1, kernel) gegeben ist.

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

#Erstellen einer 3x3-Kernel-Matrix

kernel_3x3 = np.ones ((3,3), np.float32) / 9

# Wir verwenden cv2.filter2D, um den Kernel mit einem Image zu falten

unscharf = cv2.filter2D (Bild, -1, kernel_3x3) cv2.imshow ('3x3_blurring', unscharf) cv2.waitKey (0)

#Erstellen einer 7x7-Kernelmatrix

kernel_7x7 = np.ones ((7,7), np.float32) / 49

# Wir verwenden cv2.filter2D, um den Kernel mit einem Image zu falten

unscharf = cv2.filter2D (image, -1, kernel_7x7) cv2.imshow ('7x7_blurring', unscharf) cv2.waitKey (0) cv2.destroyAllWindows ()

Es gibt auch andere Arten von Unschärfemethoden:

cv2.blur - Durchschnittlicher Wert über ein angegebenes Fenster.

cv2.GaussianBlur - Ähnlich, verwendet jedoch ein Gaußsches Fenster (stärkere Betonung der Punkte in der Mitte).

cv2.medianBlur - Verwendet den Median aller Elemente im Fenster.

cv2.bilateralFilter - Verwischt, während die Kanten scharf bleiben, wobei die Kanten und Liniendetails erhalten bleiben.

Wir werden unten eins nach dem anderen sehen, zuerst das Originalbild mit dem folgenden Code anzeigen:

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

cv2.blur:

Bei dieser Methode erfolgt die Mittelwertbildung durch Falten des Bildes mit einem normalisierten Boxfilter. Dieser nimmt den Platz unter der Box ein und ersetzt das zentrale Element. Hier muss die Boxgröße ungerade und positiv sein .

# cv2.blur blur = cv2.blur (Bild, (3,3)) cv2.imshow ('Mittelwertbildung', Unschärfe) cv2.waitKey (0)

cv2.GaussianBlur:

# cv2.GaussianBlur # Anstelle des Boxfilters versuchen wir es mit dem Gaußschen Kernel Gaussian = cv2.GaussianBlur (Bild, (7,7), 0) cv2.imshow ('Gaußsche Unschärfe', Gauß) cv2.waitKey (0)

cv2.medianBlur:

Es nimmt den Median aller Pixel unter dem Kernelbereich und das zentrale Element wird durch diesen Medianwert ersetzt.

# cv2.medianBlur # Nimmt den Median aller Pixel unter dem Kernelbereich und das zentrale Element # wird durch diesen Medianwert ersetzt. Median = cv2.medianBlur (Bild, 5) cv2.imshow ('Median Verwischung', Median) cv2.waitKey (0)

cv2.bilateralFilter:

Bilateral ist sehr effektiv bei der Geräuschentfernung, während die Kanten scharf bleiben

# cv2.bilateralFilter #Bilateral ist sehr effektiv bei der Rauschentfernung, während die Kanten bilateral scharf bleiben = cv2.bilateralFilter (Bild, 9,75,75) cv2.imshow ('bilaterale Unschärfe', bilateral) cv2.waitKey (0) cv2. destroyAllWindows ()

Bildentrauschen - nicht lokal bedeutet Entrauschen

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

#parameter after None ist die Filterstärke 'h' (5-10 ist ein guter Bereich) #next ist h für Farbkomponenten und wird wieder auf den gleichen Wert wie h gesetzt

dst = cv2.fastNlMeansDenoisingColored (Bild, Keine, 6,6,7,21) cv2.imshow ('Schnell bedeutet denois', dst) cv2.waitKey (0) cv2.destroyAllWindows ()

Es gibt 4 Varianten nicht lokaler Mittel zum Entrauschen

cv2.fastNlMeansDenoising () - für ein einzelnes Graustufenbild

cv2.fastNlMeansDenoisingColored () - Einfarbiges Bild

cv2.fastNlmeansDenoisingMulti () - für Graustufen der Bildsequenz

cv2.fastNlmeansDenoisingcoloredMulti () - für farbige Bildsequenz

3. Schärfen - Umkehren der Bildunschärfen

Das Schärfen ist das Gegenteil von Unschärfe, es verstärkt oder betont Kanten im Bild.

Kernel =,,

Unsere Kernel-Matrix summiert sich zu eins, sodass keine Normalisierung erforderlich ist (dh mit einem Faktor auf die gleiche Helligkeit wie beim Original multipliziert wird). Wenn der Kernel nicht auf 1 normalisiert wird, ist das Bild heller oder dunkler.

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

kernel_sharpening = np.array (,

])

# Anwenden des Schärfkerns auf das Eingabebild

schärfen = cv2.filter2D (Bild, -1, kernel_sharpening) cv2.imshow ('geschärftes Bild', geschärft) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Threshoding (Binarisierung)

Beim Schwellenwert wird ein Bild in eine binäre Form umgewandelt. In opencv ist eine separate Funktion für die Schwellenwertbildung definiert als

Cv2.threshold (Bild, Schwellenwert, Maximalwert, Schwellenwerttyp)

Es gibt folgende Schwellenwerttypen:

• cv2.THRESH_BINARY - am häufigsten
• cv2. THRESH_BINARY_INV - am häufigsten
• cv2.THRESH_TRUNC
• cv2.THRESH_TOZERO
• cv2. THRESH_TOZERO_INV

HINWEIS: Das Bild muss vor dem Schwellenwert in Graustufen konvertiert werden

cv2 importieren numpy als np importieren # Bild als Graustufenbild laden = cv2.imread ('gradient.jpg', 0) cv2.imshow ('original', Bild) cv2.waitKey (0)

#Wert unter 127 geht auf 0 (schwarz) und über 127 auf 255 (weiß)

_, Thresh1 = cv2.threshold (Bild, 127.255, cv2.THRESH_BINARY) cv2.imshow ('1 Schwelle', Thresh1) cv2.waitKey (0)

#Wert unter 127 geht auf 255 und Werte über 127 gehen auf 0 (Rückseite von oben)

_, Thresh2 = cv2.threshold (Bild, 127.255, cv2.THRESH_BINARY_INV) cv2.imshow ('2 Schwelle', Thresh2) cv2.waitKey (0)

#Wert über 127 wird bei 127 abgeschnitten (gehalten), das Argument 255 wird nicht verwendet.

_, Thresh3 = cv2.threshold (Bild, 127.255, cv2.THRESH_TRUNC) cv2.imshow ('3 Thresh Trunc', Thresh3) cv2.waitKey (0)

#Werte unter 127 gehen auf 0, über 127 bleiben unverändert

_, Thresh4 = cv2.threshold (Bild, 127.255, cv2.THRESH_TOZERO) cv2.imshow ('4 Schwelle', Thresh4) cv2.waitKey (0)

#Revesrse von oben, unter 127 ist unverändert, über 127 geht auf Null

_, Thresh5 = cv2.threshold (Bild, 127.255, cv2.THRESH_TOZERO_INV) cv2.imshow ('5 Schwelle', Thresh5) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Dilatation, Erosion, Öffnen / Schließen

Dies sind die Operationen auf dem Gebiet der mathematischen Morphologie

Dilatation - Fügt den Grenzen des Objekts in einem Bild Pixel hinzu.

Erosion - Entfernt Pixel an den Objektgrenzen in einem Bild.

Öffnung - Erosion gefolgt von Dilatation.

Schließen - Dilatation gefolgt von Erosion.

Das Öffnen ist sehr hilfreich beim Entrauschen der Bilder, da es das Bild zuerst durch Erosion verdünnt (das Rauschen entfernt) und dann erweitert.

Verwechslung mit Ausdehnung und Erosion

Es gibt manchmal Verwechslungen zwischen Dilatation und Erosion, normalerweise bei Bildern mit weißem Hintergrund, da opencv den weißen Hintergrund als erweitertes oder erodiertes Bild anstelle des Originalbilds betrachtet. In diesem Fall wirkt Erosion als Dilatation und umgekehrt, wie im Bildbeispiel gezeigt unten gezeigt.

Denken Sie daran, dass durch die Dilatation Pixel zu den Grenzen von Objekten in einem Bild hinzugefügt werden, während durch Erosion Pixel an den Grenzen von Objekten in einem Bild entfernt werden

cv2 importieren numpy als np importieren image = cv2.imread ('imagecv.png', 0) cv2.imshow ('original', image) cv2.waitKey (0)

#Erosion # Definieren wir unsere Kernelgröße

Kernel = np.ones ((5,5), np.uint8)

#now wir erodieren das Bild, hier ist Iteration nicht oft, wenn Sie das Bild erodieren möchten

Erosion = cv2.erode (Bild, Kernel, Iterationen = 1) cv2.imshow ('Erosion', Erosion) cv2.waitKey (0)

#Erweiterung

dilation = cv2.dilate (Bild, Kernel, Iterationen = 1) cv2.imshow ('Dilatation', Dilatation) cv2.waitKey (0)

#opening, Gut zum Entfernen des Rauschens

Eröffnung = cv2.morphologyEx (Bild, cv2.MORPH_OPEN, Kernel) cv2.imshow ('Öffnung', Öffnung) cv2.waitKey (0)

#closing, Gut zum Entfernen von Geräuschen

Schließen = cv2.morphologyEx (Bild, cv2.MORPH_CLOSE, Kernel) cv2.imshow ('Schließen', Schließen) cv2.waitKey (0) cv2.destroyAllWindows ()

6. Kantenerkennung und Bildverläufe

Die Kantenerkennung ist ein sehr wichtiger Bereich in der Bildverarbeitung, insbesondere beim Umgang mit Konturen.

Kanten können als Bildgrenzen definiert werden. Tatsächlich sind sie Kanten, die Objekte in Bildern definieren. Sie enthalten viele Informationen über das Bild.

Formal können Kanten als plötzliche Änderungen (Diskontinuitäten) in einem Bild definiert werden und so viele Informationen wie Pixel codieren.

Das obige Bild zeigt, wie Computer Vision das Bild identifiziert und erkennt.

Kantenerkennungsalgorithmen: - Es gibt drei Haupttypen von Kantenerkennungsalgorithmen

• Sobel - zur Betonung vertikaler oder horizontaler Bilder.
• Laplace - optimal aufgrund niedriger Fehlerrate, gut definierter Kanten und genauer Erkennung.
• Canny Edge-Erkennungsalgorithmus (1986 von john.F.Canny entwickelt)

1. Wendet Gaußsche Unschärfe an

2. Findet den Intensitätsgradienten des Bildes

3. Wendet eine nicht maximale Unterdrückung an (dh entfernt Pixel, die keine Kanten sind).

4. Die Hysterese wendet einen Schwellenwert an (dh wenn sich das Pixel innerhalb des oberen und unteren Schwellenwerts befindet, wird es als Kante betrachtet).

import cv2 import numpy als np image = cv2.imread ('input.jpg', 0) height, width = image.shape

#sobel

# Extrahieren von Sobel-Kanten

sobel_x = cv2.Sobel (Bild, cv2.CV_64F, 0,1, ksize = 5) sobel_y = cv2.Sobel (Bild, cv2.CV_64F, 1,0, ksize = 5) cv2.imshow ('Original', Bild) cv2.waitKey (0) cv2.imshow ('sobelx', sobel_x) cv2.waitKey (0)

#Sobely

cv2.imshow ('schluchzend', sobel_y) cv2.waitKey (0)

sobel_OR = cv2.bitwise_or (sobel_x, sobel_y) cv2.imshow ('sobelOR', sobel_OR) cv2.waitKey (0)

#laplaian

laplacian = cv2.Laplacian (Bild, cv2.CV_64F) cv2.imshow ('Laplace', laplace) cv2.waitKey (0)

#canny Kantenerkennungsalgorithmus verwendet Gradientenwerte als Schwellenwerte

#in Canny müssen zwei Werte angegeben werden: Schwellenwert1 und Schwellenwert2.

Jeder Gradient, der größer als der Schwellenwert 2 ist, wird als Kante betrachtet.

Jeder Gradient, der größer als der Schwellenwert 1 ist, wird als keine Kante betrachtet.

#values zwischen der Schwelle 1 und Schwelle 2 entweder als Kanten- oder Nicht-Kanten

#on wie ihre Intensitäten in diesen verbunden sind Fälle jeder Wert unter 60 wird als

#non Kanten wheareas jeder Wert über 120 als Kanten berücksichtigt werden.

canny = cv2.Canny (Bild, 60.120) cv2.imshow ('canny', canny) cv2.waitKey (0) cv2.destroyAllWindows ()

14. Perspektive & Affine Transformation

Lassen Sie uns einen Schritt zurücktreten und einen Blick auf affine und nicht affine Transformationen werfen. Das unten gezeigte Originalbild ist eindeutig ein nicht affines Bild, da sich die Kanten irgendwann treffen werden. Wir können es jedoch begradigen, indem wir es verziehen und die Perspektive einnehmen verwandeln.

Für diese perspektivische Transformation benötigen wir die vier Koordinaten des Originalbildes und dann die vier Punkte des Ausgabebildes. Sie werden mit points_A und points_B bezeichnet. Zunächst berechnen wir mit Hilfe dieser Punkte eine Transformationsmatrix M mit Hilfe der Funktion getPerspectiveTransform.

Und dann wird diese Matrix an die Funktion warpPerspective übergeben , um die endgültige Ausgabe zu generieren.

Versuchen wir nun zunächst die Perspektiventransformation.

cv2 importieren numpy als np importieren matplotlib.pyplot als plt importieren image = cv2.imread ('paper.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

# Koordinate von 4 Ecken des Originalbildes

points_A = np.float32 (,,,])

#Koordinaten von 4 Ecken der gewünschten Ausgabe

#Wir verwenden ein Verhältnis von A4-Papier 1: 1,41

points_B = np.float32 (,,,])

# Verwenden Sie die beiden Sätze von zwei Punkten, um die vorausschauende Transformationsmatrix M zu berechnen

M = cv2.getPerspectiveTransform (points_A, points_B) warped = cv2.warpPerspective (Bild, M, (420.594)) cv2.imshow ('warpprespective', verzogen) cv2.waitKey (0) cv2.destroyAllWindows ()

Die affine Transformation ist einfacher als die nicht affine Transformation, da wir nur drei Punkte benötigen, um die Transformation zu erhalten. Der gesamte Prozess läuft genauso ab, aber anstelle der perspektivischen Transformation haben wir jetzt eine affine Transformation und definieren Spalten und Zeilen in warpAffine über die Formfunktion, anstatt sie manuell einzugeben .

cv2 importieren numpy als np importieren matplotlib.pyplot als plt importieren image = cv2.imread ('box.jpg') Zeilen, cols = image.shape cv2.imshow ('original', image) cv2.waitKey (0)

# Koordinate von 3 Ecken des Originalbildes

points_A = np.float32 (,,])

#Koordinaten von 3 Ecken der gewünschten Ausgabe

#Wir verwenden ein Verhältnis von A4-Papier 1: 1,41

points_B = np.float32 (,,])

#Verwenden Sie die beiden Sätze von zwei Punkten, um die affine #Transformationsmatrix M zu berechnen

M = cv2.getAffineTransform (points_A, points_B) warped = cv2.warpAffine (Bild, M, (Spalten, Zeilen)) cv2.imshow ('warpaffine', verzerrt ) cv2.waitKey (0) cv2.destroyAllWindows ()

8. Live-Skizzenanwendung

Zunächst gratulieren Sie sich, dass Sie dieses Mini-Projekt nach dem Lesen aller oben genannten Bildbearbeitungsfunktionen abgeschlossen haben. In diesem Mini-Projekt von Python OpenCV lernen wir einige neue Konzepte von Schleifen und Funktionen. Wenn Sie mit der Programmierung vertraut sind, müssen Sie eine umfassendere Vorstellung von der Funktion und den Schleifen haben. In Python bleibt das Grundkonzept von Schleifen und Funktionen jedoch dasselbe, aber die Methode zu ihrer Definition ändert sich ein wenig.

Zu Beginn dieses Programms sehen wir eine bestimmte Gruppe von Anweisungen unter der Überschrift „ def Skizze (Bild) “ : Dies ist eine formale Definition einer Funktion, eine Gruppe von Anweisungen, die für eine bestimmte Ausgabe zusammenarbeiten.

Diese Skizze ist also eine Funktion, in Python wird die Funktion durch "def" definiert und endet mit einem ":". Auch die Anweisungen, die innerhalb der Funktion vorhanden sein müssen, oder Sie können sagen, welche erforderlich sind, damit die Funktion ordnungsgemäß funktioniert, werden von der Funktion automatisch seitlich ausgerichtet. Um aus den Funktionen herauszukommen, mussten die Anweisungen vollständig linksbündig ausgerichtet werden. Weitere Referenzen finden Sie bei Google, wie die Funktionen in Python definiert sind.

So in dieser Skizze Funktion haben wir mehrere Schichten der Bildverarbeitung eingeführt, die miteinander kombinieren, um eine Ausgabe zu geben. Zuerst wird das Bild in Graustufen umgewandelt, damit der OpenCV es leicht verarbeiten kann, und dann wird eine Gaußsche Unschärfe auf das Graustufenbild angewendet, um das Rauschen zu reduzieren. Dann werden die Kanten mit Hilfe des Kantenerkennungsalgorithmus des Cannys extrahiert, dann wird eine binäre Inverse auf das kantendefinierte Bild angewendet. Hier könnte die binäre Inverse auch durch bitwise_NOT erfolgen, aber wir haben diese binäre Inverse mit Schwellenwert absichtlich gewählt, da sie Freiheit gibt um seine Parameter einzustellen, bis wir ein klares Bild erhalten.

Beachten Sie auch, dass die Funktion das Argumentbild verwendet und die beiden Argumente ret und mask zurückgibt. Während das ret der Boolesche Wert ist, der angibt, dass die Funktion erfolgreich ausgeführt wurde oder nicht, und die Maske die endgültige Ausgabe der Funktion ist, dh das verarbeitete Bild.

Dann wird das zweite Konzept ist der Betrieb Webcam in opencv, die von getan wird cv2.VideoCapture (0) Funktion, die das Bild in einem Objekt speichert Kappe dass Kappe kann mit gelesen werden cap.read () Funktion, hier auch zu beachten, dass Kappe. read () befindet sich innerhalb der Endlosschleife, da die Bilder kontinuierlich aufgenommen werden mussten, um ein Gefühl für ein Live-Video zu vermitteln, bei dem die Bildrate des Videos der Bildrate Ihrer Webcam entspricht, die meist zwischen 24 und 60 liegt fps.

cap.read () gibt ret und frame zurück, wobei ret der Boolesche Wert ist, der angibt, dass die Funktion erfolgreich ausgeführt wurde oder nicht, und der Frame das von der Webcam aufgenommene Bild enthält.

Unten finden Sie den vollständigen Python OpenCV-Code zum Ausführen der Live-Skizze

import CV2 import numpy als np #sketch Erzeugungsfunktion def Skizze (Bild): #convert Bild in Graustufen img_gray = cv2.cvtColor (Bild, cv2.COLOR_BGR2GRAY) das Bild unter Verwendung von #cleaning up Gaussian blur img_gray_blur = cv2.GaussianBlur (img_gray, (5,5), 0) # Kanten extrahieren canny_edges = cv2.Canny (img_gray_blur, 10,70) #invertieren Sie das Bild ret, mask = cv2.threshold (canny_edges, 70,255, cv2.THRESH_BINARY_INV) und geben Sie die Webcam zurück, Kappe ist das Objekt von einem dritten Video - Capture - #it enthält eine Boolesche angibt, ob es erfolgreich war (ret) #it ​​enthält auch die von der Webcam (Frame) gesammelten Bilder cap = cv2.VideoCapture (0), während True: ret, frame = cap.read () cv2.imshow ('Livesketcher', Skizze (Frame)), wenn cv2.waitKey (1) == 13: # 13 ist die Enterkey Break # Release-Kamera und Fenster schließen. Denken Sie daran, die Webcam mit Hilfe von cap.release () freizugeben. Cap.release () cv2.destroyAllWindows ()

Dies ist also das Ende von Teil 2 der Bildmanipulationen in Python-OpenCV. Um Computer Vision und OpenCV besser zu verstehen, lesen Sie die vorherigen Artikel (Erste Schritte mit Python OpenCV und Bildmanipulationen in Python OpenCV (Teil 1), und Sie können mit Computer Vision etwas Cooles machen.