Automatische Bildverfolgung von Objekten

Wir werden versuchen, ein bestimmtes Farbobjekt zu erkennen und zu verfolgen. Dazu müssen wir etwas mehr darüber verstehen, wie OpenCV Farben interpretiert.

Henri Dang hat eine großartige Anleitung zur Farberkennung in Python mit OpenCV geschrieben.

Normalerweise arbeitet unsere Kamera mit dem RGB-Farbmodus, der verstanden werden kann, wenn man sich alle möglichen Farben vorstellt, die aus drei farbigen Lichtern für Rot, Grün und Blau hergestellt werden können. Wir werden hier stattdessen mit BGR (Blau, Grün, Rot) arbeiten.

Wie oben beschrieben, wird ein Pixel bei BGR durch 3 Parameter dargestellt, blau, grün und rot. Jeder Parameter hat normalerweise einen Wert von 0 – 255 (oder O bis FF in hexadezimaler Form). Ein rein blaues Pixel auf Ihrem Computerbildschirm hätte beispielsweise einen B-Wert von 255, einen G-Wert von 0 und einen R-Wert von 0.

OpenCV arbeitet mit dem HSV-Farbmodell (Hue, Saturation, Value), also einer alternativen Darstellung des RGB-Farbmodells, das in den 1970er Jahren von Computergrafikforschern entwickelt wurde, um sich besser an die Art und Weise des Menschen anzupassen das Sehen nimmt farbbildende Attribute wahr:

Großartig. Wenn Sie also eine bestimmte Farbe mit OpenCV verfolgen möchten, müssen Sie sie mit dem HSV-Modell definieren.

Beispiel

Nehmen wir an, ich muss ein gelbes Objekt wie die oben gezeigte Plastikbox verfolgen. Der einfache Teil besteht darin, seine BGR-Elemente zu finden. Sie können jedes Designprogramm verwenden, um es zu finden (ich habe PowerPoint verwendet).

In meinem Fall habe ich gefunden:

• Blau:71

• Grün:234

• Rot:213

Als nächstes müssen wir das BGR-Modell (71, 234, 213) in ein HSV-Modell umwandeln, das mit oberen und unteren Bereichsgrenzen definiert wird. Lassen Sie uns dazu den folgenden Code ausführen:

import sysimport numpy as npimport cv2blue =sys.argv[1]green =sys.argv[2]red =sys.argv[3] color =np.uint8([[[blau, grün , red]]])hsv_color =cv2.cvtColor(color, cv2.COLOR_BGR2HSV)hue =hsv_color[0][0][0]print("Untere Grenze ist:"),print("[" + str(hue- 10) + ", 100, 100]\n")print("Obere Grenze ist :"),print("[" + str(hue + 10) + ", 255, 255]")

Sie können den Code alternativ von meinem GitHub herunterladen: bgr_hsv_converter.py

Geben Sie zum Ausführen den folgenden Befehl mit den zuvor gefundenen BGR-Werten als Parameter ein:

python bgr_hsv_converter.py 71 234 213

Das Programm druckt die oberen und unteren Grenzen unserer Objektfarbe.

In diesem Fall:

untere Grenze:[24, 100, 100]

und

Obergrenze:[44, 255, 255]

Der Terminal PrintScreen zeigt das Ergebnis.

Zu guter Letzt wollen wir sehen, wie OpenCV unser Objekt „maskieren“ kann, nachdem wir seine Farbe bestimmt haben:

import cv2import numpy as np# Lies das Bild - Die 1 bedeutet, dass wir das Bild in BGRimg =cv2.imread('yellow_object.JPG', 1) # resize imag auf 20% in jedem axisimg =cv2.resize(img, (0,0), fx=0.2, fy=0.2)# BGR-Bild in ein HSV-Bild umwandelnhsv =cv2.cvtColor(img, cv2.COLOR_BGR2HSV) # NumPy zum Erstellen von Arrays für die unteren und oberen range # Das „dtype =np.uint8“ bedeutet, dass der Datentyp ein 8-Bit-Integer istlower_range =np.array([24, 100, 100], dtype=np.uint8) upper_range =np.array([44, 255, 255 ], dtype=np.uint8)# eine Maske erstellen für imagemask =cv2.inRange(hsv, lower_range, upper_range)# sowohl die Maske als auch das Bild nebeneinander anzeigencv2.imshow('mask',mask)cv2.imshow ('image', img)# warten bis der Benutzer [ ESC ] drückt während(1):k =cv2.waitKey(0) if(k ==27):breakcv2.destroyAllWindows()

Sie können den Code alternativ von meinem GitHub herunterladen: colorDetection.py

Geben Sie zum Ausführen den folgenden Befehl ein und haben in Ihrem Verzeichnis ein Foto mit Ihrem Zielobjekt (in meinem Fall:yellow_object.JPG):

python colorDetection.py

Das obige Bild zeigt das Originalbild („Bild“) und wie das Objekt aussehen wird („Maske“), nachdem die Maske angewendet wurde.

Schritt 5:Objektbewegungsverfolgung

Da wir nun wissen, wie man unser Objekt mit einer Maske „auswählt“, verfolgen wir seine Bewegung in Echtzeit mit der Kamera. Dafür habe ich meinen Code auf Adrian Rosebrocks Anleitung zum Balltracking mit OpenCV basiert.

Ich empfehle Ihnen dringend, Adrians Tutorial ausführlich zu lesen.

Bestätigen Sie zunächst, ob Sie die imutils-Bibliothek haben Eingerichtet. Es ist Adrians Sammlung von OpenCV-Komfortfunktionen, um einige grundlegende Aufgaben (wie Größenänderung oder Flip-Screen) viel einfacher zu machen. Wenn nicht, geben Sie den folgenden Befehl ein, um die Bibliothek in Ihrer Virtual Python-Umgebung zu installieren:

pip install imutils

Laden Sie als Nächstes den Code ball_tracking.py von meinem GitHub herunter und führen Sie ihn mit dem folgenden Befehl aus:

python ball_traking.py

Im Grunde ist es der gleiche Code wie der von Adrian, es sei denn, der "Video Vertical Flip", den ich mit der Zeile bekommen habe:

frame =imutils.rotate(frame, angle=180)

Beachten Sie außerdem, dass die verwendeten Maskengrenzen diejenigen waren, die wir im vorherigen Schritt erhalten haben.

Schritt 6:Testen der GPIOs

Da wir nun mit den Grundlagen von OpenCV gespielt haben, installieren wir eine LED in unserem RPi und beginnen mit unseren GPIOs zu interagieren.

Folgen Sie dem obigen Schaltplan:Die Kathode der LED wird über einen 220-Ohm-Widerstand mit GPIO 21 und ihre Anode mit GND verbunden.

Testen wir unsere LED in unserer virtuellen Python-Umgebung.

Denken Sie daran, dass RPi.GPIO möglicherweise nicht in Ihrer virtuellen Python-Umgebung installiert ist! Um dieses Problem zu beheben, müssen Sie, sobald Sie dort sind (denken Sie daran, dass sich (cv) in Ihrem Terminal befindet), pip verwenden, um es in Ihrer virtuellen Umgebung zu installieren:

pip installiere RPi.GPIO

Lassen Sie uns das Python-Skript verwenden, um einen einfachen Test auszuführen:

import sysimport timeimport RPi.GPIO as GPIO# initialize GPIO and variablesredLed =int(sys.argv[1])freq =int(sys.argv[2])GPIO.setmode(GPIO.BCM )GPIO.setup(redLed, GPIO.OUT)GPIO.setwarnings(False)print("\n [INFO] Blinkende LED (5 mal) verbunden mit GPIO {0} alle {1} Sekunde(n)".format( redLed, freq))für i im Bereich(5):GPIO.output(redLed, GPIO.LOW) time.sleep(freq) GPIO.output(redLed, GPIO.HIGH) time.sleep(freq)# do a bit of cleanupprint("\n [INFO] Beenden des Programms und Aufräumen \n")GPIO.cleanup()

Dieser Code erhält als Argument eine GPIO-Nummer und die Häufigkeit in Sekunden, die unsere LED blinken soll. Die LED blinkt 5 mal und das Programm wird beendet. Beachten Sie, dass wir vor dem Beenden die GPIOs freigeben.

Um das Skript auszuführen, müssen Sie als Parameter LED GPIO . eingeben , und Häufigkeit .

Zum Beispiel:

python LED_simple_test.py 21 1

Der obige Befehl blinkt jede "1" Sekunde 5-mal die rote LED, die mit "GPIO 21" verbunden ist.

Die Datei GPIO_LED_test.py kann von meinem GitHub heruntergeladen werden

Der obige Terminal-Druckbildschirm zeigt das Ergebnis (und Sie sollten natürlich bestätigen, dass die LED blinkt.

Jetzt arbeiten wir mit OpenCV und einigen grundlegenden GPIO-Sachen.

Schritt 7:Erkennen von Farben und GPIO-Interaktion

Lass uns beginnen, unsere OpenCV-Codes in die GPIO-Interaktion zu integrieren. Wir beginnen mit dem letzten OpenCV-Code und integrieren die GPIO-RPI-Bibliothek darauf, sodass wir die rote LED jedes Mal einschalten, wenn unser farbiges Objekt von der Kamera gefunden wird. Der in diesem Schritt verwendete Code basiert auf Adrians großartigem Tutorial OpenCV, RPi.GPIO und GPIO Zero auf dem Raspberry Pi:

Das erste, was Sie tun müssen, ist unsere LED zu „erstellen“ und sie mit dem spezifischen GPIO zu verbinden:

RPi.GPIO als GPIOredLed importieren =21GPIO.setmode(GPIO.BCM)GPIO.setwarnings(False)GPIO.setup(redLed, GPIO.OUT)

Zweitens müssen wir unsere LED initialisieren (ausgeschaltet):

GPIO.output(redLed, GPIO.LOW)ledOn =False

In der Schleife, in der der „Kreis“ erzeugt wird, wenn das Objekt gefunden wird, schalten wir nun die LED ein:

GPIO.output(redLed, GPIO.HIGH)ledOn =True

Laden Sie den vollständigen Code von meinem GitHub herunter: object_detection_LED.py

Führen Sie den Code mit dem folgenden Befehl aus:

python object_detection_LED.py

Versuchen Sie es mit verschiedenen Objekten (Farbe und Format). Sie werden sehen, dass die LED eingeschaltet wird, sobald die Farbe innerhalb der Maskengrenzen übereinstimmt.

Das Video unten zeigt einige Erfahrungen. Beachten Sie, dass nur gelbe Objekte erkannt werden, die innerhalb des Farbbereichs bleiben, und die LED einschalten. Objekte mit unterschiedlichen Farben werden ignoriert.

Wir verwenden hier nur die LED wie im letzten Schritt erklärt. Ich hatte mein Pan Tilt bereits zusammengebaut, als ich das Video gemacht habe, also ignorieren Sie es. Wir werden im nächsten Schritt mit dem PAN/TILT-Mechanismus umgehen.

Schritt 8:Der Pan-Tilt-Mechanismus

Da wir nun mit den Grundlagen von OpenCV und GPIO gespielt haben, installieren wir unseren Pan/Tilt-Mechanismus.

Weitere Informationen finden Sie in meiner Anleitung: Pan-Tilt-Multi-Servo-Control

Die Servos sollten an eine externe 5V-Versorgung angeschlossen werden, wobei ihr Daten-Pin (in meinem Fall ihre gelbe Verkabelung) wie folgt mit dem Raspberry Pi GPIO verbunden ist:

• GPIO 17 ==> Neigungsservo

• GPIO 27 ==> Pan-Servo

Vergiss nicht die GNDs miteinander zu verbinden ==> Raspberry Pi – Servos – Externe Stromversorgung)

Sie können optional einen Widerstand von 1K Ohm in Reihe zwischen Raspberry Pi GPIO und Server-Dateneingangspin schalten. Dies würde Ihr RPi im Falle eines Servoproblems schützen.

Lass uns auch die Gelegenheit nutzen und unsere Servos in unserer virtuellen Python-Umgebung testen.

Lassen Sie uns Python-Skript verwenden, um einige Tests mit unseren Treibern auszuführen:

from time import sleepimport RPi.GPIO als GPIOGPIO.setmode(GPIO.BCM)GPIO.setwarnings(False)def setServoAngle(servo, angle):pwm =GPIO.PWM(servo, 50) pwm .start(8) dutyCycle =Winkel / 18. + 3. pwm.ChangeDutyCycle(dutyCycle) sleep(0.3) pwm.stop()if __name__ =='__main__':import sys servo =int(sys.argv[1]) GPIO.setup(servo, GPIO.OUT) setServoAngle(servo, int(sys.argv[2])) GPIO.cleanup()

Der Kern des obigen Codes ist die Funktion setServoAngle(servo, angle). Diese Funktion empfängt als Argumente eine Servo-GPIO-Nummer und einen Winkelwert, an dem das Servo positioniert werden muss. Sobald die Eingabe dieser Funktion „Winkel“ ist, müssen wir sie in einen äquivalenten Arbeitszyklus umwandeln.

Um das Skript auszuführen, müssen Sie als Parameter Servo-GPIO . eingeben , und Winkel .

Zum Beispiel:

python angleServoCtrl.py 17 45

Der obige Befehl positioniert das an GPIO 17 angeschlossene Servo ("tilt") mit 45 Grad in "Elevation".

Die Datei angleServoCtrl.py kann von meinem GitHub heruntergeladen werden

Schritt 9:Ermitteln der Echtzeitposition des Objekts

Die Idee hier ist, das Objekt mit dem Pan/Tilt-Mechanismus in der Mitte des Bildschirms zu positionieren. Die schlechte Nachricht ist, dass wir zum Starten wissen müssen, wo sich das Objekt in Echtzeit befindet. Aber die gute Nachricht ist, dass es sehr einfach ist, wenn wir die Koordinaten des Objektzentrums bereits haben.

Zuerst nehmen wir den zuvor verwendeten Code "object_detect_LED" und modifizieren ihn, um die XY-Koordinaten des gefundenen Objekts zu drucken.

Laden Sie den Code von meinem GitHub herunter: objectDetectCoord.py

Der „Kern“ des Codes ist der Teil, in dem wir das Objekt finden und darauf einen Kreis mit einem roten Punkt in der Mitte zeichnen.

# nur fortfahren, wenn der Radius eine Mindestgröße erreicht, wenn radius> 10:# Kreis und Schwerpunkt auf den Rahmen zeichnen, # dann die Liste der verfolgten Punkte aktualisieren cv2.circle(frame, (int( x), int(y)), int(radius), (0, 255, 255), 2) cv2.circle(frame, center, 5, (0, 0, 255), -1) # print center of circle Koordinaten mapObjectPosition(int(x), int(y)) # wenn die LED noch nicht leuchtet, schalten Sie die LED ein, wenn nicht ledOn:GPIO.output(redLed, GPIO.HIGH) ledOn =True

Lass uns die Mittelpunktskoordinaten "exportieren" nach mapObjectPosition(int(x), int(y)) Funktion, um seine Koordinaten zu drucken. Unter der Funktion:

def mapObjectPosition (x, y):print ("[INFO] Object Center koordiniert bei X0 ={0} und Y0 ={1}".format(x, y))

Wenn wir das Programm ausführen, sehen wir an unserem Terminal die (x, y) Positionskoordinaten, wie oben gezeigt. Bewegen Sie das Objekt und beobachten Sie die Koordinaten. Wir werden feststellen, dass x von 0 bis 500 (von links nach rechts) und y von o bis 350 (von oben nach unten) reicht. Siehe die obigen Bilder.

Großartig! Jetzt müssen wir diese Koordinaten als Ausgangspunkt für unser Pan/Tilt-Tracking-System verwenden

Schritt 10:Objektpositionsverfolgungssystem

Wir möchten, dass unser Objekt immer zentriert auf dem Bildschirm bleibt. Definieren wir zum Beispiel, dass wir unser Objekt als „zentriert“ betrachten, wenn:

• 220

• 160

Außerhalb dieser Grenzen müssen wir unseren Pan/Tilt-Mechanismus bewegen, um Abweichungen auszugleichen. Darauf aufbauend können wir die Funktion mapServoPosition(x, y) . bauen wie nachstehend. Beachten Sie, dass die in dieser Funktion als Parameter verwendeten „x“ und „y“ dieselben sind, die wir zuvor zum Drucken der Mittelposition verwendet haben:

# Servos positionieren, um das Objekt in der Mitte der Framedef Map zu präsentieren positionServo (panServo, panAngle) if (x> 280):panAngle -=10 wenn panAngle <40:panAngle =40 positionServo (panServo, panAngle) if (y <160):TiltAngle +=10 wenn TiltAngle> 140:TiltAngle =140 positionServo (tiltServo, TiltAngle) wenn (y> 210):TiltAngle -=10 wenn TiltAngle <40:TiltAngle =40 PositionServo (tiltServo, TiltAngle)

Basierend auf den (x, y)-Koordinaten werden Servopositionsbefehle mit der Funktion positionServo(servo, angle) generiert. Angenommen, die y-Position ist „50“, was bedeutet, dass sich unser Objekt fast am oberen Rand des Bildschirms befindet, was übersetzt werden kann, dass „Kamerablick“ „niedrig“ ist (sagen wir ein Neigungswinkel von 120 Grad). Wir müssen also den Neigungswinkel „verringern“ (sagen wir auf 100 Grad), damit das Kameravisier „oben“ ist und das Objekt auf dem Bildschirm „unten“ geht (y erhöht sich auf sagen wir 190).

Das obige Diagramm zeigt das Beispiel in Bezug auf die Geometrie.

Überlegen Sie, wie die Pan-Kamera funktioniert. Beachten Sie, dass der Bildschirm nicht gespiegelt ist. Wenn Sie also das Objekt nach „Ihrer Linken“ bewegen, wird es auf dem Bildschirm nach „Ihrer Rechten“ verschoben, sobald Sie sich in Opposition zur Kamera befinden.

Die Funktion positionServo(servo, angle) kann geschrieben werden als:

def positionServo (servo, angle):os.system("python angleServoCtrl.py " + str(servo) + " " + str(angle)) print("[INFO] Positioning servo at GPIO {0} bis {1} Grad\n".format(servo, angle))

Wir werden das zuvor gezeigte Skript für die Servopositionierung aufrufen.

Beachten Sie, dass angleServoCtrl.py im selben Verzeichnis wie objectDetectTrac.py sein muss

Der vollständige Code kann von meinem GitHub heruntergeladen werden: objectDetectTrack.py

Schritt 11:Fazit

Wie immer hoffe ich, dass dieses Projekt anderen helfen kann, ihren Weg in die aufregende Welt der Elektronik zu finden!

Weitere Informationen und den endgültigen Code finden Sie in meinem GitHub-Depot: OpenCV-Object-Face-Tracking

Weitere Projekte finden Sie in meinem Blog: MJRoBot.org

Saludos aus dem Süden der Welt!

Wir sehen uns in meinem nächsten Tutorial!

Danke,

Quelle:  Automatisches Tracking von Vision-Objekten