Come realizzare un progetto di riconoscimento facciale Raspberry Pi

Raspberry Pi è un mini-computer a basso costo che ha reso l'elaborazione e la programmazione molto più semplici per la maggior parte delle persone, inclusi studenti e hobbisti. Questo mini-computer può fare tutto ciò che può fare un computer desktop, dalla navigazione in Internet alla realizzazione di progetti e programmi entusiasmanti. E uno di questi fantastici progetti è realizzare un riconoscimento facciale Raspberry Pi. Anche se questo progetto può essere molto interessante, non è molto facile da realizzare. Quindi, ti consiglierei di seguire l'articolo passo dopo passo.

Riconoscimento facciale Raspberry Pi

Fare un programma di riconoscimento facciale potrebbe essere stato una cosa molto difficile e avanzata una volta. Ma con Raspberry Pi, niente è troppo difficile! In questo articolo, ho usato la libreria Open Source Computer Vision (OpenCV) per realizzare il progetto.

Questo repository è stato progettato per funzionare con efficienza computazionale e applicazioni in tempo reale. Quindi, è l'ideale per il nostro programma di riconoscimento facciale in tempo reale. Questo articolo ti guiderà passo dopo passo attraverso l'intero progetto. Quindi, resta fino alla fine per avere il tuo riconoscimento facciale Raspberry Pi!

Requisiti

Avrai bisogno delle seguenti cose per creare un sistema di riconoscimento facciale Raspberry Pi:

1. Raspberry Pi V4
2. Fotocamera Noir
3. OpenCV

Connessioni Raspberry Pi

Assicurati di creare le seguenti connessioni prima di iniziare a codificare:

1. Effettua connessioni tra il Raspberry Pi e il cavo a nastro da Display
2. Collega l'SDA al pin SDA del tuo Pi
3. Metti SCL dal display al pin SCL
4. Collega il cavo a nastro della fotocamera al Raspberry Pi
5. Metti il ​​GND dal display nel Pi GND
6. Collega il Raspberry Pi 5V e il display 5V

Passaggio 1: installa OpenCV su Raspberry Pi

Il primo passo è installare OpenCV sul tuo dispositivo Pi. Per farlo, avvia il tuo Raspberry Pi e apri una connessione SSH. Per includere tutto lo spazio disponibile sulla scheda micro-SD, espandi il tuo filesystem.

$ sudo raspi-config

Quindi selezionare le “Opzioni avanzate” dal menu e successivamente “Espandi filesystem”:

Dopodiché, premi il “" e riavvia il tuo Raspberry Pi.

$ sudo reboot

Passaggio 2: conferma l'installazione di OpenCV

Una volta terminato il riavvio, dovrebbe esserci un ambiente virtuale OpenCV pronto sul tuo Pi. Ora, dovresti confermare se OpenCV è installato correttamente nel tuo Pi. Esegui il comando "source" ogni volta che apri un nuovo terminale in modo che le variabili di sistema siano impostate correttamente.

fonte ~/.profilo

Ora entra nel tuo ambiente virtuale:

lavoro sul curriculum

Il testo (cv) significa che sei nell'ambiente virtuale cv.

(cv) pi@raspberry:~$

Per entrare nel tuo interprete Python:

pitone

Vedrai apparire un ">>>" nell'interprete. Per importare la libreria OpenCV:

importa cv2

Se non ci sono messaggi di errore, puoi essere sicuro che OpenCV sia installato correttamente.

Passaggio 3: scarica OpenCV

Ora scarica il tuo OpenCV installato. Dovrai scaricare sia OpenCV che OpenCV contrib. Il contributo viene fornito con moduli e funzioni di cui avrai bisogno in questo esperimento.

$ 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.cerniera lampo

Ora, decomprimi gli archivi:

$ unzip opencv.zip $ unzip opencv_contrib.cerniera lampo

Passaggio 4: installa le dipendenze

Ora, installa le dipendenze OpenCV necessarie sul tuo Raspberry Pi per farlo funzionare correttamente:

$ 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 a gfort ottieni installa python2.7-dev python3-dev $ sudo apt-get install python3-pil.immagine

Passaggio 5: installa pip

In questo passaggio, dovrai installare un gestore di pacchetti per python chiamato "pip".

$ wget https://bootstrap.pypa.io/get-pip.py $ sudo python3 get-pip.pi

Passaggio 6: installa Numpy

Successivamente, installa una libreria Python chiamata "Numpy".

$ pip3 installa numpy

Passaggio 7: testare la fotocamera

Ora che hai installato tutte le cose necessarie, incluso OpenCV, è il momento di verificare se la tua fotocamera funziona correttamente. Dovresti già avere un Picam installato sul tuo Raspberry Pi. Inserisci il seguente codice sul tuo IDE Python:

import numpy as np import cv2 cap = cv2.VideoCapture(0) cap.set(3.640) # set Larghezza massima.set(4.480) # set Height while(True): ret, frame = cap.read() frame = cv2.flip(frame, -1) # Capovolgi la fotocamera verticalmente grigio = cv2.cvtColor(cornice, cv2.COLOR_BGR2GRIGIO) cv2.imshow('frame', frame) cv2.imshow('grigio', grigio) k = cv2.waitKey(30) & 0xff if k == 27: # premere 'ESC' per uscire dal break cap.rilascio() cv2.distruggereTutteWindows()

Questo codice funziona catturando il flusso video generato dalla tua PiCam che visualizza sia la modalità Gray che la modalità colore BGR. Quindi eseguire il codice con il seguente comando:

python simpleCamTest.pi

Ora, premi il tasto [ESC] per terminare il programma. Assicurati di fare clic sulla finestra del video prima di terminarlo. Ora dovresti vedere la tua fotocamera funzionare correttamente e mostrare i risultati. Se la fotocamera mostra i messaggi di errore "Asserzione non riuscita", utilizza il seguente comando per risolverlo:

sudo modprobe bcm2835-v4l2

Passaggio 8: rilevamento del volto

Dovresti sapere che il primo passo per completare il nostro progetto di riconoscimento facciale è fare in modo che la PiCam catturi un volto. Sicuramente, deve prima rilevare un volto per riconoscerlo in futuro.

L'algoritmo di rilevamento del volto richiede immagini con il volto e senza il volto per addestrare il classificatore e salvare le strutture da quelli. Fortunatamente, l'OpenCV che hai scaricato in anticipo viene fornito con un rilevatore e un trainer. Inoltre, ha già alcuni classificatori pre-addestrati come viso, occhi, mani, ecc. Per creare un rilevatore di volti con OpenCV, utilizzare i seguenti codici:

import numpy as np import cv2 faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml') cap = cv2.VideoCapture(0) cap.set(3.640) # set Larghezza massima.set(4.480) # imposta Altezza mentre True: ret, img = cap.leggi() img = cv2.flip(img, -1) grigio = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) facce = faceCascade.detectMultiScale( gray, scaleFactor=1.2, minNeighbors=5, minSize=(20, 20) ) per (x,y,w,h) nelle facce: cv2.rettangolo(img,(x,y),(x+w,y+h),(255,0,0),2) roi_gray = grigio[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: # premi 'ESC' per uscire dal break cap.rilascio() cv2.distruggereTutteWindows()

Ora, dovrai chiamare la funzione classificatore con alcuni fattori di scala, parametri e una dimensione minima del viso che rileverà.

facce = faceCascade.detectMultiScale( gray, scaleFactor=1.2, minVicini=5, minSize=(20, 20) )

Questo codice funziona rilevando i volti su un'immagine. Ora potresti voler contrassegnare le facce usando una forma come un rettangolo. Usa il seguente codice per farlo:

per (x,y,w,h) nelle facce: cv2.rettangolo(img,(x,y),(x+w,y+h),(255,0,0),2) roi_gray = grigio[y:y+h, x:x+w] roi_color = img[ y:y+h, x:x+w]

Quindi, ecco come funziona:

Se il classificatore trova delle facce nell'immagine, mostra le posizioni della faccia come un rettangolo come comandato dove usa "h" come altezza e "w" come larghezza e gli angoli in alto a sinistra (x, y). Questo riassume più o meno il nostro rettangolo (x,y,w,h).

Ora che hai finito con le posizioni, crea un "ROI" per il viso e mostra il risultato con la funzione imshow(). Eseguilo sull'ambiente Python usando il terminale Raspberry Pi:

python faceDetection.pi

E il risultato:

Passaggio 9: salvataggio dei dati

In questa parte, devi creare un set di dati in cui il tuo programma salverà i dati raccolti sugli ID del viso che ha rilevato. Per farlo, crea una directory (sto usando FacialRecognition):

mkdir riconoscimento facciale

Ora, crea una sottodirectory con il nome "dataset".

set di dati mkdir

Quindi, usa il seguente codice:

importa cv2 importa os cam = cv2.VideoCapture(0) cam.set(3, 640) # imposta la larghezza del video cam.set(4, 480) # imposta l'altezza del video face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') # Per ogni persona, inserisci un ID faccia numerico face_id = input('\n inserisci ID utente end press  ==>  ') print("\n [INFO] Inizializzazione acquisizione volti. Guarda la telecamera e aspetta... ") # Inizializza il conteggio delle facce di campionamento individuale = 0 while(True): ret, img = cam.leggi() img = cv2.flip(img, -1) # capovolgi l'immagine video verticalmente grigio = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) facce = face_detector.rilevaMultiScale(grigio, 1.3, 5) per (x,y,w,h) nelle facce: cv2.rettangolo(img, (x,y), (x+w,y+h), (255,0,0), 2) count += 1 # Salva l'immagine catturata nella cartella dei dataset cv2.imwrite("set di dati/Utente." + str(face_id) + '.' + str(contatore) + ".jpg", grigio[y:y+h,x:x+w]) cv2.imshow('immagine', img) k = cv2.waitKey(100) & 0xff # Premi 'ESC' per uscire dal video if k == 27: break elif count >= 10: # Prendi 10 campioni di volti e ferma l'interruzione video # Esegui un po' di pulizia print("\n [INFO] Uscita dal programma e pulizia delle cose") cam.rilascio() cv2.distruggereTutteWindows()

Nota che salveremo ciascuno dei frame acquisiti come file nella sottodirectory "dataset":

cv2.imwrite("set di dati/Utente." + str(face_id) + '.' + str(contatore) + ".jpg", grigio[y:y+h,x:x+w])

Dopodiché, devi importare la libreria "os" per salvare il file sopra. Il nome dei file seguirà una struttura come questa:

Utente.face_id.contare.jpg,/pre>

Il codice sopra menzionato catturerà solo 10 immagini per ogni id. Puoi sicuramente cambiarlo se vuoi.
Ora, prova a eseguire il programma e acquisisci alcuni ID. Assicurati di eseguire il codice ogni volta che cambi l'utente o la foto esistente.

Passaggio 10: allenatore

In questo passaggio, dovrai utilizzare una funzione OpenCV per addestrare il riconoscitore OpenCV con i dati del tuo set di dati. Inizia creando una sottodirectory per memorizzare i dati addestrati.

mkdir trainer

Quindi eseguire il seguente codice:

import cv2 import numpy as np from PIL import Image import os # Percorso per il database dell'immagine del viso percorso = 'dataset' riconoscitore = cv2.viso.LBPHFaceRecognizer_create() rilevatore = cv2.CascadeClassifier("haarcascade_frontalface_default.xml"); # funzione per ottenere le immagini e i dati dell'etichetta def getImagesAndLabels(path): imagePaths = [os.sentiero.join(percorso,f) per f in os.listdir(path)] faceSamples=[] ids = [] per imagePath in imagePaths: PIL_img = Image.apri (percorso immagine).convert('L') # convertilo in scala di grigi img_numpy = np.array(PIL_img,'uint8') id = int(os.sentiero.split(percorsoimmagine)[-1].Diviso(".")[1]) facce = rivelatore.detectMultiScale(img_numpy) per (x,y,w,h) nei volti:           faceSamples.append(img_numpy[y:y+h,x:x+w])            id.append(id) return faceSamples,ids print ("\n [INFO] Training faces. Ci vorranno alcuni secondi. Aspetta… ") faces,ids = getImagesAndLabels(path) riconoscitore.treno (facce, np.array(ids)) # Salva il modello in trainer/trainer.riconoscimento ymly.write('allenatore/allenatore.yml') # riconoscitore.save() ha funzionato su Mac, ma non su Pi # Stampa il numero di volti addestrati e termina il programma print("\n [INFO] 0 volti addestrati. Uscita dal programma".format(len(np.univoco (id))))

Assicurati di aver installato la libreria PIL sul tuo Raspberry Pi. Se non lo hai, esegui il seguente comando:

pip installa il cuscino

Qui, sto usando il riconoscimento facciale LBPH incluso nel pacchetto OpenCV. Ora, segui questa riga:

riconoscitore = cv2.viso.LBPHFaceRecognizer_create()

Tutte le tue foto verranno portate nella directory "dataset" dalla funzione "getImagesAndLabels". Restituirà 2 array denominati "Ids" e "faces". Ora è il momento di addestrare il riconoscitore.

riconoscitore.treno(facce, id)

Ora vedrai il "trainer.yml" file denominato salvato nella directory trainer trainer.

Passaggio 11: riconoscimento facciale

È il momento dell'azione finale. Dopo questo passaggio, il tuo riconoscitore può indovinare un ID di ritorno se il viso è stato catturato prima. Quindi, scriviamo il nostro codice finale:

import cv2 import numpy as np import os riconoscitore = cv2.viso.Riconoscitore LBPHFaceRecognizer_create().read('allenatore/allenatore.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2.CascadeClassifier(cascadePath); carattere = cv2.FONT_HERSHEY_SIMPLEX #iniciate id contatore id = 0 # nomi relativi agli id: esempio ==> Marcelo: id=1, ecc nomi = ['Nessuno', 'Markian', 'Bell', 'Grace', 'A', 'Z '] # Inizializza e avvia camma di acquisizione video in tempo reale = cv2.VideoCapture(0) cam.set(3, 640) # imposta la telecamera di larghezza del video.set(4, 480) # imposta l'altezza del video # Definisce la dimensione minima della finestra da riconoscere come una faccia minW = 0.1 * cam.ottieni(3) minH = 0.1 * cam.get(4) mentre True: ret, img = cam.leggi() img = cv2.flip(img, -1) # Capovolgi verticalmente grigio = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) facce = faceCascade.rilevaMultiScale (grigio, fattore di scala = 1.2, minVicini = 5, minSize = (int(minW), int(minH)), ) for(x,y,w,h) nelle facce: cv2.rettangolo(img, (x,y), (x+w,y+h), (0,255,0), 2) id, confidenza = riconoscitore.predire(grigio[y:y+h,x:x+w]) # Controlla se la fiducia è minore di loro 100 ==> "0" è corrispondenza perfetta if (fiducia < 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()

Il programma funziona come un riconoscitore. La funzione forecast() prende diverse parti del volto catturato come parametri diversi e ritorna al proprietario salvato mentre mostra l'id.
Se non riconosce il volto, mostrerà "sconosciuto" sull'immagine.

Così, Ecco!

Infine, Approfondimenti

Quindi, ecco come fai un riconoscimento facciale Raspberry Pi. Assicurati di seguire questo articolo passo dopo passo per ottenere il miglior risultato! Ora, oltre a questo classificatore di riconoscimento facciale, puoi anche effettuare il riconoscimento degli occhi o il riconoscimento del sorriso utilizzando diversi classificatori e funzioni. Ho cercato tra tutti gli articoli correlati su Internet e ho trovato questo. Quindi, spero davvero che questa guida ti abbia aiutato con i progetti. E spero che abbia successo per te. Non dimenticare di menzionare i tuoi pensieri nella sezione commenti!