OpenCV Bewegungserkennung

In diesem Artikel erfahren wir, wie wir mit Hilfe von OpenCV und Python ein Bewegungserkennungsprojekt erstellen können.

Erstellen eines Bewegungserkennungsprojekts mit OpenCV und Python

Lassen Sie uns zunächst über die Anforderungen dieses Projekts sprechen. Die erste Anforderung wird natürlich benötigt, um Python zu installieren, und wir müssen auch ein externes Paket namens opencv installieren.

Wir müssen die Eingabeaufforderung öffnen und diesen Befehl ausführen, um dieses Paket auf Ihrem PC zu installieren. Lassen Sie uns zu unserem Editor springen und mit dem Schreiben unseres Codes beginnen.

Das erste, was wir importieren, sind unsere erforderlichen Bibliotheken, cv2 und time, und als nächstes nehmen wir die Daten von unserer Webcam mit der VideoCapture()-Methode von OpenCV.

Lassen Sie uns ein Objekt namens Video erstellen, und wir müssen 0 an VideoCapture() übergeben, weil wir den 0-Kanal für die Webcam verwenden.

import cv2
import time

Video = cv2.VideoCapture(0)
First_Frame = None

Jetzt erstellen wir eine while True-Schleife oder eine Endlosschleife, weil wir ein Video extrahieren werden, und ein Video ist die kontinuierliche Bewegung auf einer Diashow von Bildern.

Jetzt definieren wir mehrere Anweisungen in einer while-Schleife und erstellen in der ersten Zeile zwei Variablen, Check und frame, und lesen die von der VideoCapture()-Methode extrahierten Daten. In der nächsten Anweisung konvertieren wir dieses extrahierte Bild in Graustufen.

Aber warum wandeln wir das in Graustufen um? Wir tun dies, weil wir die Genauigkeit der Merkmalserkennung erhöhen wollen.

Wir verwenden die Methode cvtColor(), um zu Graustufen zu wechseln, und haben zwei Parameter. Das erste ist der Rahmen oder ein Bild, das wir in Graustufen umwandeln möchten, und dann ist das nächste COLOR_BGR2GRAY, das ein Bild in graue Farbe umwandelt.

Jetzt werden wir ein Bild weichzeichnen oder glätten, wodurch die Objekterkennung oder die Bewegung eines Objekts viel einfacher wird. Wir verwenden die Methode GaussianBlur(), um eine Glättung anzuwenden, und übergeben ihr ein Graustufenbild, eine Kernelgröße und ein Sigma.

while True:
    Check, frame = Video.read()
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    gray = cv2.GaussianBlur(gray, (21, 21), 0)

Wir werden eine if-Anweisung erstellen, die prüft, ob der Frame kommt oder nicht, und wir tun dies, weil wir den First_Frame als unseren Referenzrahmen wollen.

Werfen wir einen Blick darauf, was die Physik über Bewegung sagt? Bewegung wird von einem Referenzpunkt aus identifiziert, und wir erklären dies an einem Beispiel.

Nehmen wir an, Sie sitzen in einem Zug, und für Sie bewegen sich die Bäume, aber sie bewegen sich nicht; Sie sind still, aber Sie bewegen sich von Ihrem Bezugspunkt weg. In diesem Fall sind Bäume Referenzpunkte, aber der Rahmen ist in unserem Fall eine Referenz.

Wir legen den First_Frame als unseren Referenzrahmen fest; Wenn eine Änderung gegenüber dem Referenzrahmen auftritt, können wir sagen, dass die Bewegung vorhanden ist.

Jetzt setzen wir eine Anweisung wie wenn die Variable First_Frame None ist, was im ersten Fall true ist, dann setzen wir die Variable First_Frame gleich dem Graustufenbild, das die Variable gray ist.

if First_Frame is None:
    First_Frame = gray
    continue

Wir werden die Methode absdiff() verwenden, um den Unterschied zwischen den Frames zu finden. Lassen Sie uns eine Delta-Frame-Variable erstellen und die beiden Parameter zum Vergleich an die Methode absdiff() übergeben.

Wir müssen einen Schwellenwert oder eine Grenze festlegen, bis zu der die Bewegung erkannt werden soll, da wir nicht möchten, dass die Geräusche als Bewegung erkannt werden.

Dazu verwenden wir die Methode threshold(), und sie hat ein paar Parameter, erstens ist der delta_frame, der zweite ist die Intensität, der dritte ist der Farbton, der in diesem Fall weiss ist, und dann der Das nächste ist THRESH_BINARY, da es sich um ein Tupel handelt, also müssen wir das erste Element auswählen.

Wir müssen auch in der nächsten Anweisung eine weitere Glättungsschicht auftragen. Dazu müssen wir eine weitere Glättungsfunktion namens dilate() verwenden, die drei Parameter akzeptiert, der erste ist der threshold, der zweite None und der dritte Parameter sind die iterations.

Der Parameter Iterationen definiert, wie genau Ihre Glättung sein wird; Ihr Programm erfasst die Geräusche auch, wenn Sie diesen Parameterwert erhöhen.

Dieses Mal erstellen wir die Konturen, also was sind Konturen? Konturen sind die Punkte, an denen die Bewegung stattfindet.

Wenn der Rahmen stillsteht und sich die Hand bewegt, ist der Teil der Hand die Kontur.

Die Methode findContours() hilft beim Finden von Konturen und akzeptiert drei Parameter, zuerst ist der Rahmen, und wir verwenden die Methode copy(), um die Kopie des Rahmenarrays zu erstellen.

delta_frame = cv2.absdiff(First_Frame, gray)
Threshold_frame = cv2.threshold(delta_frame, 50, 255, cv2.THRESH_BINARY)[1]
Threshold_frame = cv2.dilate(Threshold_frame, None, iterations=2)
(cntr, _) = cv2.findContours(
    Threshold_frame.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
)

Jetzt erhalten wir Konturen durch die Iteration und definieren den ungefähren Bereich als Bewegung. Wenn wir den Bereich nicht definieren, erhalten wir eine sehr laute Bewegungserkennung.

Zunächst prüfen wir, dass wir, wenn der Konturbereich kleiner als tausend ist, diesen nicht als Bewegungsbereich betrachten, und wir werden die Iteration fortsetzen, und wenn er größer als tausend ist, zeichnen wir a Dreieck.

for contour in cntr:
    if cv2.contourArea(contour) < 1000:
        continue

Die Methode findContours() gibt vier Werte (x, y, Höhe, Breite) und wir extrahieren diese Punkte mit der Methode boundingRect(), die die Fläche des Rechtecks bindet. Nun erstellen wir das Rechteck mit Hilfe der Methode rectangle().

Der erste Parameter ist der Rahmen oder das Bild, auf dem wir das Rechteck zeichnen wollen. Der nächste sind (x,y)-Koordinatenpunkte, der nächste ist Höhe und Breite, der nächste ist die Farbe des Rahmens, und dann ist der letzte Parameter die Größe des Stifts, der zum Zeichnen des Rechtecks ausgewählt wurde.

(x, y, w, h) = cv2.boundingRect(contour)
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 3)

Vollständiger Quellcode:

import cv2
import time

Video = cv2.VideoCapture(0)
First_Frame = None

while True:
    Check, frame = Video.read()
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    gray = cv2.GaussianBlur(gray, (21, 21), 0)
    if First_Frame is None:
        First_Frame = gray
        continue
    delta_frame = cv2.absdiff(First_Frame, gray)
    Threshold_frame = cv2.threshold(delta_frame, 50, 255, cv2.THRESH_BINARY)[1]
    Threshold_frame = cv2.dilate(Threshold_frame, None, iterations=2)
    (cntr, _) = cv2.findContours(
        Threshold_frame.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
    )
    for contour in cntr:
        if cv2.contourArea(contour) < 1000:
            continue
        (x, y, w, h) = cv2.boundingRect(contour)
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 3)
    cv2.imshow("Frame", frame)
    Key = cv2.waitKey(1)
    if Key == ord("q"):
        break

Video.release()
cv2.destroyAllWindows()

Jetzt können wir sehen, dass die Bewegungserkennung stattfindet, wenn sich die Hand bewegt.