Zuallererst! diese Woche werde ich mit einer kleinen Gruppe von Bloggern und Cracks auf der VMworld in Barcelona sein., Jeder, der gute Zeiten teilen möchte, sollte mir eine E-Mail schicken und wir sehen uns dort! Brunnen, mit Nougat, Ich hinterlasse Ihnen dieses Dokument mit den Schritten, die Sie befolgen, um einen Raspberry Pi mit einer USB-Kamera anzuschließen, Gesichter erkennen!

Wir müssen OpenCV installieren und lernen dann durch die Verwendung eines Skripts die Gesichter kennen, die uns interessieren, Ich werde ihm meine und die meines Txabala zeigen. Mit einem anderen Skript starten wir die Erkennungsfunktion und wenn es mein Gesicht erkennt, führt es ein Skript aus und ein anderes, wenn es das txabala erkennt.

Das erste, was wir tun müssen, ist, die OpenCV-Voraussetzungen oder andere zu installieren, die wir möglicherweise benötigen:

[sourcecode language=”Einfach”]sudo apt-get install build-essential cmake pkg-config python-dev libgtk2.0-dev libgtk2.0 zlib1g-dev libpng-dev libjpeg-dev libtiff-dev libjasper-dev libavcodec-dev swig unzip vim
sudo apt-get install python-numpy python-opencv
Sudo apt-get install python-pip
sudo apt-get install python-dev
sudo pip install picamera
sudo pip install rpio
sudo apt-get install v4l2ucp v4l-utils libv4l-dev[/Quellcode]

Nos descargamos OpenCV, lo compilamos y lo instalamos:

[sourcecode language=”Einfach”]wget http://downloads.sourceforge.net/project/opencvlibrary/opencv-unix/2.4.9/opencv-2.4.9.zip
Entpacken Sie opencv-2.4.9.zip
CD OpenCV-2.4.9
cmake -DCMAKE_BUILD_TYPE=RELEASE -DCMAKE_INSTALL_PREFIX=/usr/local -DBUILD_PERF_TESTS=AUS -DBUILD_opencv_gpu=AUS -DBUILD_opencv_ocl=AUS
Machen
sudo make install[/Quellcode]

Nicht schlecht, para el reconocimiento facial, nos descargaremos primeramente una pequeña BD de caras, damit es eine bessere Präzision hat und zu der wir unser Gesicht oder diejenigen, die uns a posteriori interessieren, hinzufügen werden. Wir laden die Beispiel-DB der AT-Datenbank für Gesichter herunter&T Laboratorien Cambridge, Zuvor erstellen wir den Ordner, in dem wir alle unsere Inhalte ablegen und entpacken:

[sourcecode language=”Einfach”]mkdir /home/pi/recoFacial
cd /home/pi/recoFacial
wget http://www.cl.cam.ac.uk/Research/DTG/attarchive/pub/data/att_faces.zip
Entpacken Sie att_faces.zip[/Quellcode]

Wir laden nun dieses XML herunter und entpacken es in /home/pi/recoFacial/:

[sourcecode language=”Einfach”]wget http://www.bujarra.com/wp-content/uploads/2016/08/haarcascade_frontalface_alt.zip
Entpacken Sie haarcascade_frontalface_alt.zip[/Quellcode]

Am Ende des Dokuments, Ich hinterlasse Ihnen ein paar Python-Dateien, Eine wird darin bestehen, Gesichter zu lernen (capture.py) und der andere, um sie zu erkennen (reconocimiento.py), Sie müssen sie ausführbar machen:

[sourcecode language=”Einfach”]chmod +x reconocimiento.py capture.py[/Quellcode]

Und eine Empfehlung, Es wäre, die Anzahl der Bilder zu erhöhen, die es aufnimmt, um unser Gesicht zu erkennen, wenn es es lernt, In einem solchen Fall, in capture.py, Statt 20 Standardbilder, Wir können zum Beispiel 100.

Um ein Gesicht zu lernen, laufen wir:

[sourcecode language=”Einfach”]python capture.py namePerson[/Quellcode]

So starten Sie das Erkennen und Erkennen von Gesichtern:

[sourcecode language=”Einfach”]Python-reconocimiento.py[/Quellcode]

capture.py

[sourcecode language=”Einfach”]
CV2 importieren, sys, Numpy, du
Größe = 4
fn_haar = 'haarcascade_frontalface_alt.xml’
fn_dir = 'att_faces/orl_faces’
fn_name = sys.argv[1]
Pfad = os.pfad.join(fn_dir, fn_name)
Wenn nicht, os.path.isdir(Pfad):
Os.mkdir(Pfad)
(im_width, im_height) = (112, 92)
haar_cascade = cv2. CascadeClassifier(fn_haar)
Webcam = CV2. VideoAufnahme(0)

Anzahl = 0
while count > 100:
(RVAL, Im) = webcam.lesen()
im = cv2.flip(Im, 1, 0)
grau = cv2.cvtColor(Im, CV2. COLOR_BGR2GRAY)
mini = cv2.resize(grau, (grau.form[1] / Größe, grau.form[0] / Größe))
faces = haar_cascade.detectMultiScale(mini)
Flächen = Sortiert(Gesichter, Schlüssel=Lambda x: x[3])
wenn Gesichter:
face_i = Flächen[0]
(x, und, w, h) = [v * Größe für V in face_i]
Gesicht = grau[und:und + h, x:x + w]
face_resize = cv2.resize(Gesicht, (im_width, im_height))
pin=sortiert([Int(n[:n.find(‘.’)]) für n in os.listdir(Pfad)
wenn n[0]!=’.’ ]+[0])[-1] + 1
cv2.imwrite('%s/%s.png’ % (Pfad, Stecknadel), face_resize)
cv2.rechteck(Im, (x, und), (x + w, und + h), (0, 255, 0), 3)
cv2.putText(Im, fn_name, (x – 10, und – 10), CV2. FONT_HERSHEY_PLAIN,
1,(0, 255, 0))
Anzahl += 1
cv2.imshow('Offene CV', Im)
Schlüssel = cv2.waitKey(10)
if Schlüssel == 27:
brechen
[/Quellcode]

reconocimiento.py

[sourcecode language=”Einfach”]
CV2 importieren, sys, Numpy, du
Größe = 4
fn_haar = 'haarcascade_frontalface_alt.xml’
fn_dir = 'att_faces/orl_faces’
# Teil 1: Creando fisherRecognizer
drucken("Formando…’)
# Crear una lista de imagenes y una lista de nombres correspondientes
(Bilder, Etiketten, Namen, Id) = ([], [], {}, 0)
für (Unterverzeichnisse, Dirs, Dateien) in os.walk(fn_dir):
für subdir in dirs:
Namen[Id] = Unterverzeichnis
BetreffPfad = os.pfad.join(fn_dir, Unterverzeichnis)
für Dateiname in os.listdir(subjectpath):
Pfad = BetreffPfad + ‘/’ + Dateiname
lable = id
images.append(cv2.imread(Pfad, 0))
lables.append(Int(Etikett))
id += 1
(im_width, im_height) = (112, 92)
# Crear una matriz Numpy de las dos listas anteriores
(Bilder, Etiketten) = [numpy.array(Lis) für lis in [Bilder, Etiketten]]
# OpenCV entrena un modelo a partir de las imagenes
model = cv2.createFisherFaceRecognizer()
Modell.Eisenbahn(Bilder, Etiketten)
# Teil 2: Verwenden von fisherRecognizer in der laufenden Kamera
haar_cascade = cv2. CascadeClassifier(fn_haar)
Webcam = CV2. VideoAufnahme(0)
während Wahr:
(RVAL, Rahmen) = webcam.lesen()
Rahmen=cv2.flip(Rahmen,1,0)
grau = cv2.cvtColor(Rahmen, CV2. COLOR_BGR2GRAY)
mini = cv2.resize(grau, (grau.form[1] / Größe, grau.form[0] / Größe))
faces = haar_cascade.detectMultiScale(mini)
Für mich in Reichweite(Len(Gesichter)):
face_i = Flächen[Ich]
(x, und, w, h) = [v * Größe für V in face_i]
Gesicht = grau[und:und + h, x:x + w]
face_resize = cv2.resize(Gesicht, (im_width, im_height))
# Versuch, das Gesicht zu erkennen
Vorhersage = Modell.Vorhersage(face_resize)
cv2.rechteck(Rahmen, (x, und), (x + w, und + h), (0, 255, 0), 3)
# Eingabe des Namens des erkannten Gesichts
# [1]
if Vorhersage[1]>500:
cv2.putText(Rahmen,
'%s – %.0f’ % (Namen[Vorhersage[0]],Vorhersage[1]),
(X-10, y-10), CV2. FONT_HERSHEY_PLAIN,1,(0, 255, 0))
#Die Variable face enthält den Namen der erkannten Person
Kopf = '%s’ % (Namen[Vorhersage[0]])
#Für den Fall, dass das Gesicht von Hector ist
if face == "HECTOR":
os.system("/startseite/pi/hector.sh")
#Für den Fall, dass das Gesicht von Seila ist
elif cara == "SEILA":
os.system("/startseite/pi/seila.sh")
#Wenn das Gesicht unbekannt ist, Unbekannt setzen
oder:
cv2.putText(Rahmen,
"Unbekannt",
(X-10, y-10), CV2. FONT_HERSHEY_PLAIN,1,(0, 255, 0))
#Es gibt niemanden
s.system("/home/pi/nadie.sh")
cv2.imshow('Offene CV', Rahmen)
Schlüssel = cv2.waitKey(10)

if Schlüssel == 27:
brechen
[/Quellcode]