Riconoscimento del viso con OpenCv

La complessità delle macchine è aumentata nel corso degli anni e i computer non sono un'eccezione. I computer hanno aiutato l'umanità a risolvere molti problemi e a completare molti compiti difficili. Sono finiti i giorni in cui tutti i computer hanno fatto erano semplici operazioni aritmetiche, i computer ora guidano il mondo.

I computer sono diventati così complessi che sono addestrati a pensare come umani.
SÌ!

Faremo qualcosa di quella natura in questo articolo. Come 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 poter fare lo stesso.

Molti articoli che vedresti là fuori si fermano a un semplice rilevamento del viso, ma in questo articolo coprirebbe non solo il rilevamento del viso ma anche il riconoscimento del viso.

Ciò significa che se il computer fosse presentato con due foto di me, non solo riconoscerebbe quale parte dell'immagine sia il mio viso, ma riconoscerebbe anche che io sono quello in entrambe le immagini.

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

Per installare Apri CV, possiamo farlo usando il comando PIP.

PIP Installa OpenCv-Python

In questo articolo faremo anche uso del pacchetto numpy, che dovrebbe essere installato insieme a OpenCV usando il comando sopra.

Se Numpy non ha installato, puoi farlo facilmente usando il comando qui sotto:

PIP Installa numpy

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

Importa CV2

Se non ricevere 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 a riconoscere i volti in base ai risultati della formazione che il computer passa.

Avremmo bisogno della cascata di Haar fornita da Open CV. Questo file può essere ottenuto dalla directory OpenCV che è CV2/Data/HaarCascade_Frontalface_Default.XML sulla mia macchina dovrebbe essere uguale anche sulla tua macchina. Copia il file nella cartella in cui si desidera fare il riconoscimento del viso.

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

Importa CV2
vid_cam = cv2.VideOCapture (0)
face_detector = cv2.Cascadeclassifier ('haarcascade_frontalface_default.XML ')
face_id = 1
conta = 0
while (vid_cam.è aperto()):
ret, image_frame = vid_cam.Leggere()
grigio = cv2.CVTColor (Image_Frame, CV2.Color_bgr2gray)
facce = face_detector.DetectMultSiscal (grigio, 1.3, 5)
per (x, y, w, h) in facce:
Cv2.Rettangolo (Image_Frame, (x, y), (x+w, y+h), (255,0,0), 2)
conta += 1
Cv2.imwrite ("set di dati/utente." + str (face_id) + '.' + str (count) + ".jpg ", grigio [y: y+h, x: x+w])
Cv2.imshow ('frame', image_frame)
Se Cv2.WaitKey (100) e 0xff == Ord ('Q'):
rottura
Elif Count> 100:
rottura
vid_cam.pubblicazione()
Cv2.DestroyAllWindows ()

Quindi per spiegare cosa fa ogni riga di codice:

Importa CV2

Ecco il comando che dice a Python di includere una libreria esterna da utilizzare in questo codice, in questo caso è aperto CV.

vid_cam = cv2.VideOCapture (0)

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

face_detector = cv2.Cascadeclassifier ('haarcascade_frontalface_default.XML ')

Per essere in grado di eseguire il rilevamento delle immagini, questo codice è necessario. Apri CV utilizza il 'HaarCascade_Frontalface_Default.XML 'per la classificazione a cascata. L'oggetto risultante viene quindi archiviato nella variabile Face_Detector.

face_id = 1

Ecco un caso per impostare il numero ID del viso, quindi la prima faccia ottiene un ID di 1.

conta = 0

Prenderemo un paio di immagini poiché il CV aperto deve formare immagini per essere in grado di riconoscere i volti, la variabile del conteggio funge da conteggio delle immagini.

while (vid_cam.è aperto()):

Ciò consente di procedere le seguenti operazioni a condizione che venga aperta la videocamera. Il metodo isopened () restituisce vero o falso.

ret, image_frame = vid_cam.Leggere()

Qui, vid_cam.Read () esamina l'acquisizione del video e quindi cattura il frame che viene memorizzato nella variabile Image_Frame, se l'operazione ha esito positivo il vero true booleano viene restituito e memorizzato nella variabile RET

grigio = cv2.CVTColor (Image_Frame, CV2.Color_bgr2gray)

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.DetectMultSiscal (grigio, 1.3, 5)

Questo controlla frame di dimensioni diverse e cerca di metterli in scala, questo viene applicato sulla variabile a cui è stata applicata la cascata HAAR.

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

Qui ci avviciniamo ai volti e alle sue dimensioni, dove X e Y rappresentano rispettivamente le coordinate e W e H per la larghezza e l'altezza.

Cv2.Rettangolo (Image_Frame, (x, y), (x+w, y+h), (255,0,0), 2)

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

conta += 1

Immediatamente ciò che viene fatto, la variabile di conteggio che si erge come un contatore aumenta quindi.

Cv2.imwrite ("set di dati/utente." + str (face_id) + '.' + str (count) + ".jpg ", grigio [y: y+h, x: x+w])

L'immagine ritagliata è salvata con il nome utente (face_id).(contare).jpg e messo in una cartella chiamata set di dati.

Cv2.imshow ('frame', image_frame)

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

Se Cv2.WaitKey (100) e 0xff == Ord ('Q'):
rottura

Dopo ogni immagine, all'utente è autorizzato a impedire al programma di scattare più immagini che possono essere fatte premendo la "Q" sulla tastiera per almeno 100ms.

Elif Count> 100:
rottura

Quello che fa questo codice è impedire al video di lavorare nel momento in cui sono state scattate 100 immagini, indipendentemente dal fatto che l'utente voglia prendere di più o no.

vid_cam.pubblicazione()

Qui, la web cam è chiusa e non si è limitata a scattare foto.

Cv2.DestroyAllWindows ()

Quindi tutte le Windows OpenCV sono state distrutte sono state distrutte e il codice è concluso.

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

Importa CV2, sistema operativo
Importa Numpy come NP
Dall'immagine di importazione PIL
Riconoscimento = CV2.viso.createlbphfacerecognizer ()
Detector = CV2.Cascadeclassifier ("haarcascade_frontalface_default.XML ");
def getimagesandlabels (percorso):
ImagePaths = [OS.sentiero.Unisciti (percorso, F) per F in OS.ListDir (Path)]
facesamples = []
ids = []
Per il percorso di immagine nei per passi:
Pil_img = immagine.aperto (ImagePath).converti ('l')
img_numpy = np.array (pil_img, 'uint8')
id = int (OS.sentiero.Split (ImagePath) [-1].diviso(".") [1])
facce = rivelatore.DetectMultScale (IMG_NUMPY)
per (x, y, w, h) in facce:
Facesamples.append (img_numpy [y: y+h, x: x+w])
IDS.append (ID)
Facesampli di ritorno, IDS
facce, ids = getImagesandlabels ('set di dati')
Riconoscimento.treno (facce, NP.Array (IDS))
Riconoscimento.Salva ('allenatore/allenatore.YML ')

Andiamo avanti e spieghiamo anche questo codice:

Importa CV2, sistema operativo

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).

Dall'immagine di importazione PIL

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

Riconoscimento = CV2.viso.createlbphfacerecognizer ()

Ciò che fa è applicare il metodo createlbphfacerecognizer () al CV2.Face Object, questo contribuirebbe a rendere facile il riconoscimento dei volti in quanto non dobbiamo trovare il nostro set di algoritmi.

Detector = CV2.Cascadeclassifier ("haarcascade_frontalface_default.XML ");

Se avessi seguito il tutorial, ci saresti imbattuto prima. Aiuta con il rilevamento del viso usando "Haarcascade_frontalface_default.XML "per la classificazione Cascade.

def getimagesandlabels (percorso):

Ora stiamo per iniziare la formazione dell'immagine, quindi creiamo una funzione.

ImagePaths = [OS.sentiero.Unisciti (percorso, F) per F in OS.ListDir (Path)]

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

facesamples = []

Questo inizializza un elenco di campioni, è vuoto a questo punto, ma i volti verrebbero aggiunti man mano che il codice funziona.

ids = []

Inizializza un elenco di ID, che è inizialmente vuoto.

Per il percorso di immagine nei per passi:

Ricorda il codice che ha controllato i file di immagine nella directory? SÌ? Ora, passeremo attraverso ciascuno di quei file e effettueremo operazioni su di essi.

Pil_img = immagine.aperto (ImagePath).converti ('l')

Ora la prima cosa che facciamo all'immagine è convertirlo 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 unico posto, quindi creiamo un array numpy da loro e la assegniamo a una variabile.

id = int (OS.sentiero.Split (ImagePath) [-1].diviso(".") [1])

Se ricordi il file che ottiene le immagini, ricorderesti che abbiamo chiamato l'utente dei file (face_id).contare.jpg. Quindi qui stiamo dividendo i nomi con "."E poi estraiamo il face_id e assegniamo a una variabile qui. Avremmo bisogno dell'ID per il riconoscimento.

facce = rivelatore.DetectMultScale (IMG_NUMPY)

Dall'array numpy, il metodo DetectMultScale () proverà a rilevare i volti dal modello che trova nell'array numpy. Quindi assegna i valori nella variabile Faces.

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

Qui, stiamo passando attraverso i valori assegnati alla variabile. I valori qui sono le coordinate xey che potremmo prendere come origine, e quindi W e H in piedi rispettivamente per la larghezza e la larghezza.

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

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

IDS.append (ID)

Ora abbiamo un elenco di campioni di faccia in faccia, quindi otteniamo il suo ID e lo aggiungiamo anche all'elenco IDS.

Facesampli di ritorno, IDS

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

facce, ids = getImagesandlabels ('set di dati')

Ricorda che getImagesandlabels () è solo una funzione. Quindi possiamo chiamare la funzione qui e i valori di ritorno vengono salvati nelle variabili Faces e IDS.

Riconoscimento.treno (facce, NP.Array (IDS))

Qui è dove accade il vero allenamento. Abbiamo applicato il metodo createlbphfacerecognizer () qualche tempo prima e assegnato a una variabile di riconoscimento. È il tempo di allenamento!

Riconoscimento.Salva ('allenatore/allenatore.YML ')

Dopo l'allenamento, possiamo salvare i risultati dalla formazione.
Dopo aver eseguito il codice, crea un file chiamato trainer.YML che verrebbe quindi utilizzato dal codice di riconoscimento facciale.

Ecco il codice di riconoscimento facciale:

Importa CV2
Importa Numpy come NP
Riconoscimento = CV2.viso.createlbphfacerecognizer ()
Riconoscimento.Load ('Trainer/Trainer.YML ')
cascadepath = "haarcascade_frontalface_default.XML "
FaceCascade = CV2.CascadeClassifier (CascadePath)
FONT = CV2.Font_hershey_simplex
Cam = Cv2.VideOCapture (0)
mentre è vero:
ret, im = cam.Leggere()
grigio = cv2.CVTCOLOR (IM, CV2.Color_bgr2gray)
facce = faceCascade.DetectMultSiscal (grigio, 1.2,5)
per (x, y, w, h) in facce:
Cv2.Rettangolo (IM, (X-20, Y-20), (x+W+20, Y+H+20), (0,255,0), 4)
Id = riconoscimento.prevedere (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 ('im', im)
Se Cv2.waitkey (10) e 0xff == ord ('q'):
rottura
Camera.pubblicazione()
Cv2.DestroyAllWindows ()

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

Riconoscimento.Load ('Trainer/Trainer.YML ')

Ricorda che abbiamo addestrato il riconoscimento e salvato un file? SÌ? Stiamo caricando quel file ora.

cascadepath = "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.

FONT = CV2.Font_hershey_simplex

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

Cam = Cv2.VideOCapture (0)

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

mentre è vero:
ret, im = cam.Leggere()
grigio = cv2.CVTCOLOR (IM, CV2.Color_bgr2gray)
facce = faceCascade.DetectMultSiscal (grigio, 1.2,5)
per (x, y, w, h) in facce:

Tutti questi sono stati fatti prima, controlla gentilmente il codice 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 pone un rettangolo per indicare una faccia.

Id = riconoscimento.prevedere (grigio [y: y+h, x: x+w])

Abbiamo alrrady caricato il file del treno nel riconoscimento, quindi è in grado di riconoscere il viso ora.

if (id == 1):
Id = "me stesso"
altro:
Id = "sconosciuto"

Dopo aver cercato di riconoscere ciò che è volto, controlla l'ID e vede se esiste. Qui, il valore dell'ID sarebbe il nome di chiunque fosse posseduto il di fronte a un tale ID quando il set di dati dell'immagine veniva creato.

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 attorno al viso e posiziona il nome del proprietario del viso. Faccia riconosciuta!

Cv2.imshow ('im', im)

Qui, il frame video viene visualizzato con il rettangolo limitato.

Se Cv2.waitkey (10) e 0xff == ord ('q'):
rottura
Camera.pubblicazione()
Cv2.DestroyAllWindows ()

Quindi, quando è finito, è possibile interrompere il programma premendo il tasto "Q" e interrompe la webcam e lo chiude.

Ecco qua, la tua webcam ora può riconoscere i volti e puoi usarlo ogni volta che lo desideri. Ai sensi dell'utilizzo della webcam è anche possibile caricare un'immagine, tuttavia ciò richiede altri passaggi rispetto a quelli presi in questo articolo.