Riconoscimento facciale con OpenCV

La complessità delle macchine è aumentata negli anni e i computer non fanno eccezione. I computer hanno aiutato l'umanità a risolvere molti problemi e completare molti compiti difficili difficult. Sono finiti i giorni in cui tutti i computer facevano semplici operazioni aritmetiche, i computer ora guidano il mondo.

I computer sono diventati così complessi che vengono addestrati a pensare come gli umani.
sì!

Faremo qualcosa del genere in questo articolo. Come esseri umani, riconoscere i volti delle altre persone è un compito semplice e nonostante le capacità dei computer di oggi non è così facile per il computer, quindi dobbiamo addestrarlo per essere in grado di fare lo stesso.

Molti articoli che vedresti là fuori si fermano al semplice rilevamento del volto, ma in questo articolo tratterebbe non solo il rilevamento del volto ma anche il riconoscimento del volto.

Ciò significa che se al computer vengono presentate due mie foto, non solo riconoscerà quale parte dell'immagine è il mio viso, ma riconoscerà anche che sono quello in entrambe le immagini.

Per cominciare, dovremmo prima installare opencv sulle nostre macchine, cosa che può essere fatta solo se hai installato Python. L'installazione di Python non è l'obiettivo di questo articolo, quindi se non lo hai già sulla tua macchina puoi installare Python dal sito Web di Python.

Per installare Open CV, possiamo farlo usando il comando pip.

pip install opencv-python

Utilizzeremo anche il pacchetto numpy in questo articolo, che dovrebbe essere installato insieme a OpenCV usando il comando sopra.

Se numpy non è stato installato, puoi farlo facilmente usando il comando seguente:

pip install numpy

Per confermare che il tuo OpenCV è installato, quando attivi l'ambiente interattivo di Python prova a importarlo usando:

importa cv2

Se non ricevi un errore, puoi procedere.

Per eseguire il riconoscimento facciale, scriveremmo tre script. Uno per creare un set di dati di immagini, un altro per addestrare quelle immagini e poi l'ultimo per riconoscere i volti in base ai risultati dell'allenamento che il computer passa.

Avremmo bisogno dell'Haar Cascade fornito da Open CV. Questo file può essere ottenuto dalla directory opencv che è cv2/data/haarcascade_frontalface_default.xml sulla mia macchina dovrebbe essere lo stesso anche sulla tua macchina. Copia il file nella cartella in cui desideri eseguire il riconoscimento facciale.

Ora entriamo nel vivo delle cose.
Cercheremmo di ottenere la nostra web cam per ottenere le immagini, necessarie per il set di dati.

importa cv2
vid_cam = cv2.Acquisizione video(0)
face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
face_id = 1
conteggio = 0
mentre (vid_cam.è aperto()):
ret, image_frame = vid_cam.leggere()
grigio = cv2.cvtColor(image_frame, cv2.COLORE_BGR2GRIGIO)
facce = face_detector.rilevaMultiScale(grigio, 1.3, 5)
per (x,y,w,h) nelle facce:
cv2.rettangolo(fotogramma_immagine, (x,y), (x+w,y+h), (255,0,0), 2)
contare += 1
cv2.imwrite("set di dati/Utente." + str(face_id) + '.' + str(contatore) + ".jpg", grigio[y:y+h,x:x+w])
cv2.imshow('frame', image_frame)
se cv2.waitKey(100) & 0xFF == ord('q'):
rompere
elif conteggio>100:
rompere
vid_cam.pubblicazione()
cv2.distruggereTutteWindows()

Quindi, per spiegare cosa fa ogni riga di codice:

importa cv2

Ecco il comando che dice a python di includere una libreria esterna da usare in questo codice, in questo caso è Open CV.

vid_cam = cv2.Acquisizione video(0)

Questo codice richiama la libreria Open CV importata per iniziare l'acquisizione e la webcam viene avviata a questo punto. Se Open CV non supporta la tua webcam, il codice fallirà qui.

face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

Per consentirci di eseguire il rilevamento dell'immagine, è necessario questo codice. Open CV utilizza il 'haarcascade_frontalface_default.xml' per la classificazione a cascata. L'oggetto risultante viene quindi memorizzato nella variabile face_detector.

face_id = 1

Ecco un caso di impostazione del numero ID della faccia, quindi la prima faccia ottiene un ID di 1.

conteggio = 0

Scatteremo un paio di immagini poiché Open CV ha bisogno di addestrare le immagini per essere in grado di riconoscere i volti, la variabile di conteggio funge da conteggio delle immagini.

mentre (vid_cam.è aperto()):

Ciò consente di procedere alle seguenti operazioni purché la videocamera sia aperta. Il metodo isOpened() restituisce True o False.

ret, image_frame = vid_cam.leggere()

Ecco, la vid_cam.read() esamina l'acquisizione video e quindi acquisisce il frame che è memorizzato nella variabile image_frame, se l'operazione ha esito positivo viene restituito il valore booleano True e memorizzato nella variabile ret

grigio = cv2.cvtColor(image_frame, cv2.COLORE_BGR2GRIGIO)

Il metodo cvtColor() viene utilizzato per convertire la cornice dell'immagine nel tipo di colore desiderato. In questo caso l'abbiamo convertito in scala di grigi.

facce = face_detector.rilevaMultiScale(grigio, 1.3, 5)

Questo controlla i frame di diverse dimensioni e cerca di impostarli in scala, questo viene applicato alla variabile a cui è stato applicato Haar Cascade.

per (x,y,w,h) nelle facce:

Qui passiamo attraverso le facce e le sue dimensioni, dove x e y stanno per le coordinate e w e h stanno rispettivamente per larghezza e altezza.

cv2.rettangolo(fotogramma_immagine, (x,y), (x+w,y+h), (255,0,0), 2)

Ricorda che stiamo ancora lavorando con la videocamera, la videocamera quindi ritaglia la parte necessaria dell'immagine in base alle dimensioni sopra.

contare += 1

Immediatamente fatto, la variabile di conteggio che funge da contatore quindi aumenta.

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

L'immagine ritagliata è quella salvata con il nome User(face_id).(contare).jpg e mettilo in una cartella chiamata dataset.

cv2.imshow('frame', image_frame)

Dopo il salvataggio, questo codice garantisce che l'immagine del fotogramma video venga visualizzata con un rettangolo sul viso dell'individuo dopo che è stato eseguito il rilevamento del viso.

se cv2.waitKey(100) & 0xFF == ord('q'):
rompere

Dopo ogni immagine, l'utente può interrompere il programma per scattare più foto, cosa che può essere fatta premendo il tasto 'q' sulla tastiera per almeno 100 ms.

elif conteggio>100:
rompere

Ciò che fa questo codice è interrompere il funzionamento del video nel momento in cui sono state scattate 100 foto, indipendentemente dal fatto che l'utente voglia prenderne di più o meno.

vid_cam.pubblicazione()

Qui, la web cam è chiusa e non solo ha smesso di scattare foto.

cv2.distruggereTutteWindows()

Quindi tutte le finestre aperte da OpenCV sono state distrutte e il codice viene eseguito fino alla conclusione.

Ora che abbiamo finito, possiamo quindi addestrare il set di dati dell'immagine:

importa cv2, os
importa numpy come np
da PIL import Immagine
riconoscitore = cv2.viso.createLBPHFaceRecognizer()
rivelatore = cv2.CascadeClassifier("haarcascade_frontalface_default.xml");
def getImagesAndLabels(percorso):
imagePaths = [os.sentiero.join (percorso, f) per f in os.listdir(percorso)]
faceSamples=[]
ID = []
per imagePath in imagePaths:
PIL_img = Immagine.apri (percorso immagine).convert('L')
img_numpy = np.array(PIL_img,'uint8')
id = int(os.sentiero.split(percorsoimmagine)[-1].Diviso(".")[1])
facce = rivelatore.rilevaMultiScale(img_numpy)
per (x,y,w,h) nelle facce:
faceSamples.append(img_numpy[y:y+h,x:x+w])
ID.append (id)
return faceSamples,ids
facce,ids = getImagesAndLabels('dataset')
riconoscitore.treno (facce, np.array(id))
riconoscitore.save('allenatore/allenatore.yml')

Andiamo avanti e spieghiamo anche questo codice:

importa cv2, os

Proprio come l'altro codice, qui stiamo importando OpenCV e os di cui avremmo bisogno per il percorso del file.

importa numpy come np

Stiamo anche importando la libreria numpy che verrebbe utilizzata per il calcolo della matrice (una matrice è solo una disposizione di array).

da PIL import Immagine

Stiamo importando la libreria di immagini Python e quindi da essa stiamo ottenendo anche la libreria di immagini da questo pacchetto.

riconoscitore = cv2.viso.createLBPHFaceRecognizer()

Ciò che fa è applicare il metodo createLBPHFaceRecognizer() al cv2.oggetto faccia, questo aiuterebbe a rendere facile il riconoscimento dei volti in quanto non dobbiamo inventare il nostro set di algoritmi.

rivelatore = cv2.CascadeClassifier("haarcascade_frontalface_default.xml");

Se hai seguito il tutorial, lo avresti trovato prima. Aiuta con il rilevamento dei volti utilizzando "haarcascade_frontalface_default.xml” per la classificazione a cascata.

def getImagesAndLabels(percorso):

Ora stiamo per iniziare l'addestramento dell'immagine vero e proprio, quindi creiamo una funzione.

imagePaths = [os.sentiero.join(percorso,f) per f in os.listadir(percorso)]

Questo codice controlla la directory corrente del file e controlla i file di immagine, quindi li aggiunge a questo elenco.

faceSamples=[]

Questo inizializza un elenco di campioni, a questo punto è vuoto ma le facce verrebbero aggiunte durante l'esecuzione del codice.

ID = []

Inizializza un elenco di ID, che inizialmente è vuoto.

per imagePath in imagePaths:

Ricorda il codice che ha controllato i file immagine nella directory? sì? Ora esamineremo ciascuno di questi file ed eseguiremo operazioni su di essi.

PIL_img = Immagine.apri (percorso immagine).convert('L')

Ora la prima cosa che facciamo all'immagine è convertirla in scala di grigi, e questo codice lo fa.

img_numpy = np.array(PIL_img,'uint8')

L'immagine in scala di grigi è solo una serie di numeri tutti in un posto, quindi ne creiamo un array numpy e lo assegniamo a una variabile.

id = int(os.sentiero.split(percorsoimmagine)[-1].Diviso(".")[1])

Se ricordi il file che ottiene le immagini, ricorderai che abbiamo chiamato i file User(face_id).contare.jpg. Quindi qui stiamo dividendo i nomi con il ".” e poi estraiamo il face_id e assegniamo a una variabile qui. Ci servirebbe l'id per il riconoscimento.

facce = rivelatore.rilevaMultiScale(img_numpy)

Dall'array numpy, il metodo detectMultiScale() proverà a rilevare le facce dal pattern che trova nell'array numpy. Quindi assegna i valori nella variabile facce.

per (x,y,w,h) nelle facce:

Qui, stiamo scorrendo i valori assegnati alla variabile. I valori qui sono le coordinate x e y che potremmo prendere come origine, e quindi w e h rispettivamente per larghezza e altezza.

faceSamples.append(img_numpy[y:y+h,x:x+w])

In precedenza abbiamo creato un elenco di campioni di volti, ma era vuoto. Qui possiamo aggiungere facce a quell'elenco e stiamo aggiungendo y a h in modo da ottenere i due valori delle coordinate y e lo stesso è fatto per x.

ID.append (id)

Ora abbiamo una faccia nell'elenco dei campioni di volti, quindi otteniamo il suo ID e lo aggiungiamo anche all'elenco degli ID.

return faceSamples,ids

Quindi, dopo tutto, restituiamo l'elenco dei campioni di volti e l'elenco degli ID.

facce,ids = getImagesAndLabels('dataset')

Ricorda che getImagesAndLabels() è solo una funzione. Quindi possiamo chiamare la funzione qui e i valori restituiti vengono salvati nelle variabili face e ids.

riconoscitore.treno (facce, np.array(id))

Ecco dove avviene il vero allenamento. Abbiamo applicato il metodo createLBPHFaceRecognizer() qualche tempo prima e assegnato a una variabile di riconoscimento. È tempo di allenamento!

riconoscitore.save('allenatore/allenatore.yml')

Dopo l'allenamento, possiamo salvare i risultati dell'allenamento.
Dopo aver eseguito il codice, crea un file chiamato trainer.yml che verrebbe poi utilizzato dal codice di riconoscimento facciale.

Ecco il codice di riconoscimento facciale:

importa cv2
importa numpy come np
riconoscitore = cv2.viso.createLBPHFaceRecognizer()
riconoscitore.load('allenatore/allenatore.yml')
cascataPath = "haarcascade_frontalface_default_.xml"
faceCascade = cv2.CascadeClassifier(cascadePath)
carattere = cv2.FONT_HERSHEY_SIMPLEX
camma = cv2.Acquisizione video(0)
mentre vero:
ret, im = cam.leggere()
grigio = cv2.cvtColor(im,cv2.COLOR_BGR2GRIGIO)
facce = faceCascade.rilevaMultiScale(grigio, 1.2,5)
for(x,y,w,h) nelle facce:
cv2.rettangolo(im, (x-20,y-20), (x+w+20,y+h+20), (0,255,0), 4)
Id = riconoscitore.predire(grigio[y:y+h,x:x+w])
if(Id == 1):
Id = "Nazmi"
altro:
ID = "Sconosciuto"
cv2.rettangolo(im, (x-22,y-90), (x+w+22, y-22), (0,255,0), -1)
cv2.putText(im, str(Id), (x,y-40), font, 2, (255,255,255), 3)
cv2.imshow('io',io)
se cv2.waitKey(10) & 0xFF == ord('q'):
rompere
Camera.pubblicazione()
cv2.distruggereTutteWindows()

Se hai seguito l'articolo dall'inizio, lo abbiamo già fatto prima. Se non l'hai gentilmente fatto.

riconoscitore.load('allenatore/allenatore.yml')

Ricorda che abbiamo addestrato il riconoscitore e salvato un file? sì? Stiamo caricando quel file ora.

cascataPath = "haarcascade_frontalface_default_.xml"

Lavoreremmo con il file haarcascade, e qui abbiamo assegnato il nome del file a una variabile.

# Crea classificatore dal modello predefinito
faceCascade = cv2.CascadeClassifier(cascadePath)

Qui possiamo eseguire la classificazione Cascade sul file haarcascade.

carattere = cv2.FONT_HERSHEY_SIMPLEX

Impostiamo il tipo di carattere che verrebbe utilizzato quando il codice riconosce il volto in un'immagine e visualizza il nome.

camma = cv2.Acquisizione video(0)

Siamo già stati qui, ma questa volta è il momento di riconoscere i volti. Se non sai cosa fa questo codice, avvia la webcam.

mentre vero:
ret, im = cam.leggere()
grigio = cv2.cvtColor(im,cv2.COLORE_BGR2GRIGIO)
facce = faceCascade.rilevaMultiScale(grigio, 1.2,5)
for(x,y,w,h) nelle facce:

Tutto questo è stato fatto prima, controlla gentilmente il codice che è stato utilizzato per salvare le immagini se non sai cosa fa il codice.

cv2.rettangolo(im, (x-20,y-20), (x+w+20,y+h+20), (0,255,0), 4)

Quindi questo aiuta la webcam a rilevare dove si trovano i volti e posiziona un rettangolo per indicare un volto.

Id = riconoscitore.predire(grigio[y:y+h,x:x+w])

Abbiamo già caricato il file del treno nel riconoscitore, quindi ora è in grado di riconoscere il volto.

if(Id == 1):
Id = "Me stesso"
altro:
ID = "Sconosciuto"

Dopo aver provato a riconoscere che faccia è, controlla l'id e vede se esiste. Qui, il valore dell'Id sarebbe il nome di chi possedeva il volto con tale ID quando è stato creato il set di dati dell'immagine.

cv2.rettangolo(im, (x-22,y-90), (x+w+22, y-22), (0,255,0), -1)
cv2.putText(im, str(Id), (x,y-40), font, 2, (255,255,255), 3)

Il codice dopo aver trovato il proprietario dell'Id, disegna un rettangolo intorno alla faccia e inserisce il nome del proprietario della faccia. Volto riconosciuto!

cv2.imshow('io',io)

Qui, il fotogramma video viene visualizzato con il rettangolo delimitato.

se cv2.waitKey(10) & 0xFF == ord('q'):
rompere
Camera.pubblicazione()
cv2.distruggereTutteWindows()

Quindi, una volta terminato, puoi interrompere il programma premendo il tasto 'q', arresta la webcam e la chiude.

Ecco fatto, la tua webcam ora può riconoscere i volti e puoi usarla quando vuoi whenever. Oltre a utilizzare la webcam puoi anche caricare un'immagine, tuttavia ciò richiede alcuni passaggi diversi da quelli presi in questo articolo.

Puoi trovare il codice sorgente utilizzato nel suo repository github. Twittaci anche se hai commenti o vuoi discutere di @linuxhint