Phenquestions
Raspberry Pi ist ein kostengünstiger Mini-Computer, der das Rechnen und Programmieren für die meisten Menschen, einschließlich Studenten und Bastler, erheblich erleichtert hat. Dieser Mini-Computer kann alles, was ein Desktop-Computer kann, vom Surfen im Internet bis hin zum Erstellen spannender Projekte und Programme. Und eines dieser erstaunlichen Projekte ist die Erstellung einer Raspberry Pi-Gesichtserkennung. Obwohl dieses Projekt sehr interessant sein kann, ist es nicht sehr einfach zu machen. Daher würde ich dir empfehlen, dem Artikel Schritt für Schritt zu folgen.
Raspberry Pi Gesichtserkennung
Ein Gesichtserkennungsprogramm zu erstellen war vielleicht einmal eine sehr schwierige und fortgeschrittene Sache thing. Aber mit Raspberry Pi ist nichts zu schwer! In diesem Artikel habe ich die Open Source Computer Vision Library (OpenCV) verwendet, um das Projekt durchzuführen.
Dieses Repository wurde entwickelt, um mit Recheneffizienz und Echtzeitanwendungen zu arbeiten. Daher ist es ideal für unser Echtzeit-Gesichtserkennungsprogramm. Dieser Artikel führt Sie Schritt für Schritt durch das gesamte Projekt. Bleiben Sie also am Ende, um Ihre eigene Raspberry Pi-Gesichtserkennung zu haben!
Bedarf
Sie benötigen die folgenden Dinge, um ein Raspberry Pi-Gesichtserkennungssystem zu erstellen:
- Raspberry Pi V4
- Noir-Kamera
- OpenCV
Raspberry Pi-Anschlüsse
Stellen Sie sicher, dass Sie die folgenden Verbindungen erstellen, bevor Sie mit der Codierung beginnen:
- Stellen Sie Verbindungen zwischen dem Raspberry Pi und dem Flachbandkabel vom Display her
- Befestigen Sie den SDA am SDA-Pin Ihres Pi
- Setzen Sie den SCL vom Display auf den SCL-Pin
- Verbinden Sie das Flachbandkabel der Kamera mit dem Raspberry Pi
- Legen Sie den GND vom Display in den Pi GND
- Verbinden Sie den Raspberry Pi 5V und die 5V des Displays
Schritt 1: OpenCV auf Raspberry Pi installieren
Der erste Schritt besteht darin, OpenCV auf Ihrem Pi-Gerät zu installieren. Starten Sie dazu Ihren Raspberry Pi und öffnen Sie eine SSH-Verbindung. Um den gesamten verfügbaren Speicherplatz auf der Micro-SD-Karte einzuschließen, erweitern Sie Ihr Dateisystem.
$ sudo raspi-config
Wählen Sie dann die „Erweiterten Optionen“ aus dem Menü und anschließend „Dateisystem erweitern“:
Drücken Sie danach die “
$ sudo Neustart
Schritt 2: OpenCV-Installation bestätigen
Sobald Sie mit dem Neustart fertig sind, sollte sich auf Ihrem Pi . eine fertige virtuelle OpenCV-Umgebung befinden. Jetzt sollten Sie überprüfen, ob OpenCV korrekt in Ihrem Pi . installiert ist. Führen Sie den Befehl „source“ jedes Mal aus, wenn Sie ein neues Terminal öffnen, damit die Systemvariablen korrekt eingerichtet sind.
Quelle ~/.Profil
Betreten Sie nun Ihre virtuelle Umgebung:
Arbeitslebenslauf
Der Text (cv) bedeutet, dass Sie sich in der virtuellen Umgebung des Lebenslaufs befinden.
(cv) pi@raspberry:~$
So geben Sie Ihren Python-Interpreter ein:
Python
Im Dolmetscher wird ein „>>>“ angezeigt. So importieren Sie die OpenCV-Bibliothek:
CV2 importieren import
Wenn keine Fehlermeldungen erscheinen, können Sie sicher sein, dass OpenCV richtig installiert ist.
Schritt 3: OpenCV herunterladen
Laden Sie jetzt Ihr installiertes OpenCV herunter. Sie müssen sowohl OpenCV als auch OpenCV herunterladen. Der Beitrag enthält Module und Funktionen, die Sie in diesem Experiment benötigen.
$ cd ~ $ wget -O opencv.zip https://github.com/opencv/opencv/archive/4.0.0.zip $ wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/4.0.0.Postleitzahl
Entpacken Sie nun die Archive:
$ opencv entpacken.zip $ entpacken opencv_contrib.Postleitzahl
Schritt 4: Abhängigkeiten installieren
Installieren Sie nun die erforderlichen OpenCV-Abhängigkeiten auf Ihrem Raspberry Pi, damit er ordnungsgemäß funktioniert:
$ sudo apt-get update && sudo apt-get upgrade $ sudo apt-get install build-essential cmake pkg-config $ sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng-dev $ sudo apt-get install libavcodec -dev libavformat-dev libswscale-dev libv4l-dev $ sudo apt-get install libxvidcore-dev libx264-dev $ sudo apt-get install libgtk2.0-dev libgtk-3-dev $ sudo apt-get install libfontconfig1-dev libcairo2-dev $ sudo apt-get install libgdk-pixbuf2.0-dev libpango1.0-dev $ sudo apt-get install libhdf5-dev libhdf5-serial-dev libhdf5-103 $ sudo apt-get install libqtgui4 libqtwebkit4 libqt4-test python3-pyqt5 $ sudo apt-get install libatlas-base-dev gfortran $ python2 installieren install.7-dev python3-dev $ sudo apt-get install python3-pil.imagetk
Schritt 5: Installieren Sie pip
In diesem Schritt müssen Sie einen Paketmanager für Python namens „pip“ installieren.
$ wget https://bootstrap.pypa.io/get-pip.py $ sudo python3 get-pip.py
Schritt 6: Numpy installieren
Installieren Sie danach eine Python-Bibliothek namens „Numpy“.
$ pip3 install numpy
Schritt 7: Testen Sie die Kamera
Nachdem Sie nun alle notwendigen Dinge installiert haben, einschließlich OpenCV, ist es an der Zeit zu überprüfen, ob Ihre Kamera richtig funktioniert. Auf Ihrem Raspberry Pi sollte bereits ein Picam installiert sein. Geben Sie den folgenden Code in Ihre Python-IDE ein:
import numpy as np import cv2 cap = cv2.VideoCapture(0)-Kappe.set(3,640) # set Breite cap.set(4,480) # set Height while(True): ret, frame = cap.read() Frame = cv2.flip(frame, -1) # Kamera vertikal spiegeln grau = cv2.cvtColor (Rahmen, cv2.COLOR_BGR2GRAY) cv2.imshow('frame', frame) cv2.imshow('grau', grau) k = cv2.waitKey(30) & 0xff if k == 27: # 'ESC' drücken, um Break Cap zu beenden.release() cv2.zerstörenAllWindows() Dieser Code funktioniert, indem er den von Ihrer PiCam generierten Videostream erfasst, der sowohl den Graumodus als auch den BGR-Farbmodus anzeigt. Führen Sie dann den Code mit dem folgenden Befehl aus:
python simpleCamTest.py
Drücken Sie nun die [ESC]-Taste, um das Programm zu beenden. Stellen Sie sicher, dass Sie auf das Videofenster klicken, bevor Sie es beenden. Sie sollten jetzt sehen, dass Ihre Kamera ordnungsgemäß funktioniert und Ergebnisse anzeigt. Wenn Ihre Kamera die Fehlermeldung „Assertion failed“ anzeigt, verwenden Sie den folgenden Befehl, um dies zu beheben:
sudo modprobe bcm2835-v4l2
Schritt 8: Gesichtserkennung
Sie sollten wissen, dass der erste Schritt zum Abschluss unseres Gesichtserkennungsprojekts darin besteht, die PiCam ein Gesicht erfassen zu lassen. Sicherlich muss es zuerst ein Gesicht erkennen, um es in Zukunft wiedererkennen zu können.
Der Gesichtserkennungsalgorithmus benötigt sowohl Bilder mit dem Gesicht als auch ohne Gesicht, um den Klassifikator zu trainieren und Strukturen daraus zu speichern. Glücklicherweise enthält das zuvor heruntergeladene OpenCV einen Detektor und einen Trainer. Außerdem gibt es bereits einige vortrainierte Klassifikatoren wie Gesicht, Augen, Hände usw. Um einen Gesichtsdetektor mit OpenCV zu erstellen, verwenden Sie die folgenden Codes:
import numpy as np import cv2 faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml') cap = cv2.VideoCapture(0)-Kappe.set(3,640) # set Breite cap.set(4,480) # set Height während True: ret, img = cap.read() img = cv2.flip(img, -1) grau = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) Gesichter = faceCascade.DetectMultiScale(grau, scaleFactor=1.2, minNeighbors=5, minSize=(20, 20) ) für (x,y,w,h) in Flächen: cv2.Rechteck(img,(x,y),(x+w,y+h),(255,0,0),2) roi_gray = grau[y:y+h, x:x+w] roi_color = img[ y:y+h, x:x+w] cv2.imshow('video',img) k = cv2.waitKey(30) & 0xff if k == 27: # 'ESC' drücken, um Break Cap zu beenden.release() cv2.zerstörenAllWindows() Jetzt müssen Sie die Klassifikatorfunktion mit einigen Skalierungsfaktoren, Parametern und einer minimalen Größe des Gesichts, die sie erkennt, aufrufen.
Gesichter = faceCascade.DetectMultiScale(grau, scaleFactor=1.2, minNachbarn=5, minGröße=(20, 20) )
Dieser Code funktioniert, indem er Gesichter auf einem Bild erkennt. Jetzt möchten Sie vielleicht die Gesichter mit einer Form als Rechteck markieren. Verwenden Sie dazu den folgenden Code:
für (x,y,w,h) in Flächen: cv2.Rechteck(img,(x,y),(x+w,y+h),(255,0,0),2) roi_gray = grau[y:y+h, x:x+w] roi_color = img[ y:y+h, x:x+w]
Also, so funktioniert es:
Wenn der Klassifikator Gesichter im Bild findet, zeigt er die Positionen der Gesichter wie befohlen als Rechteck an, wobei "h" als Höhe und "w" als Breite und die linken oberen Ecken (x,y) verwendet werden. Das fasst unser Rechteck ziemlich gut zusammen (x,y,w,h).
Nachdem Sie mit den Standorten fertig sind, erstellen Sie einen „ROI“ für das Gesicht und zeigen Sie das Ergebnis mit der Funktion imshow() an. Führen Sie es in der Python-Umgebung mit dem Raspberry Pi Terminal aus:
Python-Gesichtserkennung.py
Und das Ergebnis:
Schritt 9: Daten speichern
In diesem Teil müssen Sie einen Datensatz erstellen, in dem Ihr Programm die gesammelten Daten über die IDs des erkannten Gesichts speichert. Erstellen Sie dazu ein Verzeichnis (ich verwende FacialRecognition):
mkdir Gesichtserkennung
Erstellen Sie nun ein Unterverzeichnis mit dem Namen „dataset“.
mkdir-Datensatz
Verwenden Sie dann den folgenden Code:
cv2 importieren os cam importieren = cv2.VideoCapture(0)-Kamera.set(3, 640) # Videobreite Kamera einstellen.set(4, 480) # setze die Videohöhe face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') # Geben Sie für jede Person eine numerische Gesichts-ID ein face_id = input('\n Geben Sie die Benutzer-ID ein end press ==> ') print("\n [INFO] Initialisieren der Gesichtserfassung. Schauen Sie in die Kamera und warten Sie ... ") # Initialisieren Sie die Anzahl der einzelnen Abtastgesichtszahlen = 0 while(True): ret, img = cam.read() img = cv2.flip(img, -1) # Videobild vertikal spiegeln grau = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) Gesichter = face_detector.DetectMultiScale(grau, 1.3, 5) für (x,y,w,h) in Flächen: cv2.Rechteck(img, (x,y), (x+w,y+h), (255,0,0), 2) count += 1 # Speichern Sie das aufgenommene Bild im Datensatzordner cv2.imwrite("Datensatz/Benutzer." + str(face_id) + '.' + str(Anzahl) + ".jpg", grau[y:y+h,x:x+w]) cv2.imshow('image', img) k = cv2.waitKey(100) & 0xff # Drücken Sie 'ESC', um das Video zu beenden, wenn k == 27: Elifzähler unterbrechen >= 10: # Nehmen Sie 10 Gesichtsproben und stoppen Sie die Videopause # Machen Sie ein bisschen Aufräumen print("\n [INFO] Programm beenden und Sachen aufräumen") cam.release() cv2.zerstörenAllWindows() Beachten Sie, dass wir jeden der erfassten Frames als Datei im Unterverzeichnis „dataset“ speichern werden:
cv2.imwrite("Datensatz/Benutzer." + str(face_id) + '.' + str(Anzahl) + ".jpg", grau[y:y+h,x:x+w]) Danach müssen Sie die Bibliothek „os“ importieren, um die obige Datei zu speichern. Der Name der Dateien folgt einer Struktur wie dieser:
Benutzer.face_id.Anzahl.jpg,/pre>
Der oben erwähnte Code erfasst nur 10 Bilder für jede ID. Das kannst du sicher ändern, wenn du willst.
Versuchen Sie nun, das Programm auszuführen und einige IDs zu erfassen. Stellen Sie sicher, dass Sie den Code jedes Mal ausführen, wenn Sie den Benutzer oder das vorhandene Foto ändern.
Schritt 10: Trainer
In diesem Schritt müssen Sie eine OpenCV-Funktion verwenden, um den OpenCV-Erkenner mit den Daten aus Ihrem Datensatz zu trainieren. Erstellen Sie zunächst ein Unterverzeichnis zum Speichern der trainierten Daten.
mkdir-Trainer
Führen Sie dann den folgenden Code aus:
import cv2 import numpy as np from PIL import Image import os # Path for face image database path = 'dataset' Recognizer = cv2.Gesicht.LBPHFaceRecognizer_create() Detektor = cv2.CascadeClassifier("haarcascade_frontalface_default.xml"); # Funktion zum Abrufen der Bilder und Labeldaten def getImagesAndLabels(path): imagePaths = [os.Pfad.join(path,f) für f in os.listdir(path)] faceSamples=[] ids = [] for imagePath in imagePaths: PIL_img = Image.open(imagePath).convert('L') # in Graustufen umwandeln img_numpy = np.array(PIL_img,'uint8') id = int(os.Pfad.split(imagePath)[-1].Teilt(".")[1]) Gesichter = Detektor.detectMultiScale(img_numpy) für (x,y,w,h) in Gesichtern: faceSamples.append(img_numpy[y:y+h,x:x+w]) ids.append(id) return faceSamples,ids print ("\n [INFO] Gesichter trainieren. Es dauert ein paar Sekunden. Warte…") Gesichter,ids = getImagesAndLabels(Pfad)-Erkenner.train(Gesichter, np.array(ids)) # Speichern Sie das Modell in trainer/trainer.yml-Erkenner.schreiben('Trainer/Trainer.yml') # Erkenner.save() funktionierte auf Mac, aber nicht auf Pi # Print the number of face trained and end program print("\n [INFO] 0 trainierte Gesichter. Programm beenden".format(len(np.eindeutig(ids)))) Stellen Sie sicher, dass Sie die PIL-Bibliothek auf Ihrem Raspberry Pi installiert haben. Wenn Sie das nicht haben, führen Sie den folgenden Befehl aus:
Pip installieren Kissen
Hier verwende ich den LBPH-Gesichtserkenner, der im OpenCV-Paket enthalten ist. Folgen Sie nun dieser Zeile:
Erkenner = cv2.Gesicht.LBPHFaceRecognizer_create()
Alle Ihre Fotos werden von der Funktion „getImagesAndLabels“ in das Verzeichnis „dataset“ verschoben. Es werden 2 Arrays namens "Ids" und "faces" zurückgegeben. Jetzt ist es an der Zeit, den Erkenner zu trainieren.
Erkenner.Zug (Gesichter, Ausweise)
Jetzt sehen Sie den „Trainer“.yml“ benannte Datei, die im Trainerverzeichnis gespeichert ist.
Schritt 11: Gesichtserkennung
Es ist Zeit für die letzte Aktion. Nach diesem Schritt kann Ihr Erkenner eine zurückkehrende ID erraten, wenn das Gesicht zuvor aufgenommen wurde. Schreiben wir also unseren endgültigen Code:
cv2 importieren numpy als np importieren OS-Erkenner importieren = cv2.Gesicht.LBPHFaceRecognizer_create()-Erkenner.read('Trainer/Trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2.CascadeClassifier(cascadePath); Schriftart = cv2.FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # Namen im Zusammenhang mit IDs: Beispiel ==> Marcelo: id=1, etc. names = ['None', 'Markian', 'Bell', 'Grace', 'A', 'Z '] # Initialisieren und starten Sie die Echtzeit-Videoaufnahme cam = cv2.VideoCapture(0)-Kamera.set(3, 640) # Video mit Kamera einstellen.set(4, 480) # set video height # Definiere die minimale Fenstergröße, die als Gesicht erkannt werden soll minW = 0.1 * Kamera.get(3) minH = 0.1 * Kamera.get(4) while True: ret, img =cam.read() img = cv2.flip(img, -1) # Vertikal spiegeln grau = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) Gesichter = faceCascade.DetectMultiScale( grau, scaleFactor = 1.2, minNeighbors = 5, minSize = (int(minW), int(minH)), ) for(x,y,w,h) in Faces: cv2.Rechteck(img, (x,y), (x+w,y+h), (0,255,0), 2) id, Vertrauen = Erkenner recognize.Predict(gray[y:y+h,x:x+w]) # Prüfen, ob Konfidenz kleiner als 100 ==> "0" ist perfekt, wenn (Konfidenz < 100): id = names[id] confidence = " 0%".format(round(100 - confidence)) else: id = "unknown" confidence = " 0%".format(round(100 - confidence)) cv2.putText(img, str(id), (x+5,y-5), font, 1, (255,255,255), 2) cv2.putText(img, str(confidence), (x+5,y+h-5), font, 1, (255,255,0), 1) cv2.imshow('camera',img) k = cv2.waitKey(10) & 0xff # Press 'ESC' for exiting video if k == 27: break # Do a bit of cleanup print("\n [INFO] Exiting Program and cleanup stuff") cam.release() cv2.destroyAllWindows() Das Programm arbeitet als Erkenner. Die Funktion vorhersagen () verwendet verschiedene Teile des erfassten Gesichts als unterschiedliche Parameter und kehrt zum gespeicherten Besitzer zurück, während die ID angezeigt wird.
Wenn das Gesicht nicht erkannt wird, wird auf dem Bild „unbekannt“ angezeigt.
So, Voila!
Endlich Einblicke
So erstellen Sie eine Raspberry Pi-Gesichtserkennung. Folgen Sie diesem Artikel Schritt für Schritt, um das beste Ergebnis zu erzielen! Jetzt können Sie neben diesem Gesichtserkennungs-Klassifikator auch Augen- oder Lächelnerkennung mit verschiedenen Klassifikatoren und Funktionen durchführen. Ich habe alle verwandten Artikel im Internet recherchiert und bin auf diesen gekommen. Ich hoffe also wirklich, dass dieser Leitfaden Ihnen bei den Projekten geholfen hat. Und ich hoffe, dass es für dich erfolgreich ist. Vergiss nicht, deine Gedanken im Kommentarbereich zu erwähnen!
