Rilevamento facciale e sorriso in tempo reale con OpenCV 4 e Raspberry Pi

Sperimentiamo con la libreria OpenCV 4 in un progetto di riconoscimento facciale e rilevamento del sorriso in tempo reale.

Nell’articolo “Realizzare un sistema di sorveglianza con Raspberry Pi e OpenCV” abbiamo introdotto la libreria OpenCV 4 per Raspberry Pi, che rappresenta un potente strumento in grado di realizzare applicazioni in ambito di riconoscimento d’immagine con il semplice ausilio di una telecamera specifica per Raspberry Pi.

Nella stessa occasione vi abbiamo spiegato come si installa la libreria OpenCV 4 per la piattaforma Raspbian e in che modo si può utilizzare una scheda Raspberry Pi per creare un semplice sistema di riconoscimento del movimento attraverso l’analisi delle immagini riprese dalla specifica telecamera per la stessa board.

Adesso proseguiamo sullo stesso filone analizzando nuove funzionalità della libreria con l’obiettivo di realizzare un sistema di riconoscimento facciale in grado di rilevare un volto, gli occhi e una bocca sorridente; il tutto in tempo reale.

Haar Cascades

Una tecnica utilizzata da OpenCV 4 per il rilevamento dei volti si basa sulle cosiddette Haar Cascades. In altre parole, sono classificazioni in cascata basate sull’algoritmo di Haar, chiamate così in onore al matematico ungherese Alfréd Haar, famoso per i suoi studi a inizio 1900 e al quale è stata riconosciuta la wavelet di Haar.

Le Haar Cascades rappresentano un metodo di rilevamento ottico degli oggetti molto efficace, proposto da Paul Viola e Michael Jones nel loro articolo “Rapid Object Detection using a Boosted Cascade of Simple Features” del 2001, che tradotto suona come “Rilevamento rapido degli oggetti usando cascate incrementate di caratteristiche semplici”.

Si tratta di un approccio al machine learning basato su una funzione a cascata che viene “addestrata” da caratteristiche semplici. Come spieghiamo a breve, la tecnica con wavelet di Haar crea dei riquadri in positivo e negativo da usare come filtri da sovrapporre in sequenza a un’immagine, dalla cui interazione si estraggono le informazioni necessarie per capire dove si trovi una certa caratteristica dell’oggetto, per esempio, un volto, gli occhi e la bocca (Fig. 1).

 

Come si può vedere nella figura, i riquadri che si ottengono con la wavelet di Haar si suddividono in tre Features (termine traducibile come “caratteristiche”, ma lo lasceremo in inglese perché normalmente si utilizza tale termine gergale):

(a) Edge Features
(b) Line Features
(c) Four-rectangle Features
Queste Feature vengono applicate in cascade (cascata) e, inizialmente, l’algoritmo richiede molte immagini di volti e immagini senza volti.

Questo è il metodo per “addestrare” il cosiddetto classifier (classificatore). A questo scopo, vengono utilizzate le Features di Haar, la cui applicazione è visibile nella Fig. 2. È facile intuire come l’algoritmo di Haar, produca riquadri rettangolari bianchi e neri, tramite una matrice a onda quadra.

 

Si fa notare che le immagini da elaborare devono essere trasformate in una scala di grigi, se sono a colori. Questo per facilitare il calcolo con i riquadri bianchi e neri.

Successivamente, una volta trovata la caratteristica di un volto, degli occhi eccetera, si potrà riutilizzare l’immagine a colori.

Ogni Feature viene estratta da un singolo valore, ottenuto sottraendo la somma dei pixel sotto il rettangolo bianco dalla somma dei pixel sotto il rettangolo nero. I riquadri si muovono velocemente su tutta l’immagine e vengono utilizzate tutte le dimensioni e le posizioni possibili del volto per calcolare le Feature.

Per una finestra di 24×24 pixel servono oltre 160.000 Features e per ogni calcolo di Feature, è necessario trovare la somma dei pixel sotto i rettangoli bianchi e neri.

Per risolvere questo problema e per quanto grande sia l’immagine da elaborare, i calcoli per un dato pixel vengono ridotti a un’operazione che coinvolge solo quattro pixel alla volta, rendendo il tutto molto veloce.

Di tutte queste Feature che vengono calcolate, la maggior parte è irrilevante. Per esempio, se osserviamo la Fig. 2, la linea in alto mostra due buone Feature. La prima Feature selezionata sembra concentrarsi sulla proprietà che la regione degli occhi è spesso più scura della regione del naso e delle guance.

La seconda Feature si basa sulla proprietà che gli occhi sono più scuri del naso. Ma le stesse finestre applicate sulle guance o su qualsiasi altro posto sono irrilevanti.

Quindi, per selezionare le migliori Feature fra 160.000 è stato realizzato un algoritmo Adaboost, con il quale viene trovata la soglia migliore per la classificazione dei volti. Per la cronaca, AdaBoost, abbreviazione di Adaptive Boosting, è un meta-algoritmo di apprendimento automatico, formulato per essere utilizzato nel machine learning.

Ovviamente, durante l’operazione di estrazione delle Feature, ci saranno errori o errate classificazioni, per cui vengono selezionate le Feature con un tasso di errore minimo per rilevare più accuratamente le immagini di volti.

Il processo non è così semplice: ad ogni immagine viene dato un peso uguale all’inizio, dopo ogni classificazione vengono aumentati i pesi delle immagini errate, quindi viene eseguito lo stesso processo e vengono calcolati nuovi tassi di errore e nuovi pesi.

Il processo prosegue fino a quando viene raggiunta la precisione richiesta o il tasso di errore minimo. Il classificatore finale è una somma ponderata di questi classificatori “deboli”. Si chiamano deboli perché da soli non possono classificare l’immagine, ma insieme ad altri formano un classificatore forte. L’esperienza fatta sul campo ci dice che anche 200 Feature forniscono il rilevamento con un’accuratezza del 95%.

La configurazione finale avrà circa 6.000 Feature e questa riduzione da 160.000 a 6.000 è un grande vantaggio. Come vedremo, tutti i parametri dei classificatori (classifier) sono salvati in file pronti all’uso (file pre-addestrati).

Cascade of Classifiers

Nonostante la riduzione a circa 6.000 Feature, per ridurre il tempo per il rilevamento di un volto, è stato introdotto il concetto di Cascade of Classifiers (cascata di classificatori).

Di solito, in un fotogramma la maggior parte dell’immagine non è una faccia, quindi il metodo migliore è quello di verificare se una regione della foto non è una faccia.

Se non lo è, questa regione viene scartata subito e non viene elaborata di nuovo, a tutto vantaggio dell’ottimizzazione delle risorse e dei tempi di elaborazione. Invece, le regioni in cui può esserci una faccia vengono elaborate per controllare e analizzare le possibili aree del viso.

Per ottenere questo risultato il concetto di Cascade of Classifiers invece di applicare tutte le 6.000 Feature in una finestra, le raggruppa in diversi stadi di classificatori e quindi applicate una per una. Se una finestra fallisce il primo stadio, viene scartato e non vengono considerate le restanti Feature. Se invece passa, viene applicata la seconda fase delle Feature e il processo continua.

La finestra che passa tutte le fasi è una regione del viso.

Questa regione viene chiamata ROI (Region of Interest) e sarà quella che verrà presa in considerazione per una successiva analisi.

Haar-cascade di OpenCV 4

OpenCV è dotato di un allenatore e di un rilevatore. Se si vuole “allenare” il classificatore per identificare qualsiasi oggetto come auto, aerei ecc. si può usare OpenCV per crearne uno.

I dettagli completi non possiamo trattarli (per brevità) in questo articolo, ma sappiate che si trovano sul sito Internet ufficiale di OpenCV, alla pagina web Cascade Classifier Training.

In questa sede ci occuperemo solo del rilevamento. OpenCV 4 contiene già molti classificatori pre-addestrati per il riconoscimento di viso, occhi, sorrisi, corpi, targhe automobilistiche ecc. I relativi file XML sono disponibili nella cartella opencv/data/haarcascades (almeno, se avete eseguito l’installazione di OpenCV in modo corretto).

 

Rilevamento di volto e occhi con OpenCV

Qui di seguito presentiamo un semplice listato in Python in grado di effettuare un rilevamento di volto e occhi da un’immagine fissa.

Per prima cosa dobbiamo caricare i classificatori XML richiesti per il rilevamento del viso e degli occhi:

haarcascade_frontalface_default.xml
haarcascade_eye.xml

I più curiosi vorranno sapere che cosa contengono questi file XML. Giusto per dare un’idea della struttura, affrermeremo che, oltre alla tipica struttura di un file XML, si possono distinguere i tag relativi alla finestra di 24×24 pixel e i tag dei weakClassifiers (classificatori deboli).

A seconda del tipo di rilevamento, ci sono quasi 3.000 tag chiamati internalNodes a cui sono abbinati altrettanti tag rects e circa 6.000 tag leafValues. I numeri si possono riferire a misure e coordinate dei rettangoli e ai valori di soglia degli stadi di classificazione (stageThreshold).

Il Listato 1 riporta un estratto dal file haarcascade_frontalface_default.xml.

Consigliamo di copiare i suddetti classificatori XML dalla cartella /home/pi/opencv/data/haarcascades in una nuova cartella; noi l’abbiamo chiamata face_eye_detect. All’interno di questa cartella mettete anche un’immagine jpg.

Per il nostro esempio abbiamo usato l’immagine dell’autore, contenuta nel file “pier.jpg”.

Attenzione! Prima di iniziare a lavorare con Python, ricordatevi di attivare il profilo per l’ambiente virtuale “cv” e di aprire l’idle di Python con i comandi seguenti dal terminale, come illustrato in Fig. 3:

source ~/.profile
workon cv
python -m idlelib.idle

Per i dettagli vi rimandiamo all’articolo “Home automation con OpenCV 4” pubblicato nel fascicolo n°233 di Elettronica In.
Analizzando il listato in Python, per prima cosa, importiamo le librerie necessarie:

import sys
import os
import numpy as np
import cv2 as cv

Quindi, creiamo l’oggetto face_cascade con i classificatori ottenuti dall’importazione del primo file XML per il rilevamento della faccia.

Allo stesso modo, creiamo l’oggetto eye_cascade con i classificatori ottenuti dall’importazione del secondo file XML per il rilevamento degli occhi.

Quindi, carichiamo l’immagine jpg da analizzare e la trasformiamo in scala di grigi con la funzione cv.COLOR_BGR2GRAY.

L’oggetto img conterrà le informazioni dell’immagine e l’oggetto gray quelle dell’immagine trasformata in scala di grigi.
Procediamo quindi con i comandi:

face_cascade = cv.CascadeClassifier(‘haarcascade_frontalface_default.xml’)
eye_cascade = cv.CascadeClassifier(‘haarcascade_eye.xml’)
img = cv.imread(‘pier.jpg’)
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

 

A questo punto possiamo cercare il volto nell’immagine tramite la funzione face_cascade.detectMultiScale(gray, 1.3, 5).

Il ciclo for cerca un volto all’interno dell’oggetto faces passando le coordinate x e y e le dimensioni di larghezza e di altezza w e h della Feature.

Se viene trovato un volto, la sua posizione sarà evidenziata con un rettangolo blu, tramite la funzione cv.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2).

Una volta che otteniamo la posizione del viso, possiamo creare una cosiddetta ROI (Region of Interest) per il viso e applicare il rilevamento degli occhi su questa ROI, dal momento che gli occhi sono sempre sul viso.

Con lo stesso procedimento, una volta rilevati gli occhi, questi vengono evidenziati con due rettangoli verdi:

faces = face_cascade.detectMultiScale(gray, 1.3, 5)
for (x,y,w,h) in faces:
cv.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
roi_gray = gray[y:y+h, x:x+w]
roi_color = img[y:y+h, x:x+w]

eyes = eye_cascade.detectMultiScale(roi_gray)
for (ex,ey,ew,eh) in eyes:
cv.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)

Infine, viene creata una finestra con l’istruzione cv.imshow(‘img’,img) per visualizzare il risultato. La finestra “img” contenente il risultato è visibile nella Fig. 4.
Una volta chiusa la finestra, il programma viene terminato:

cv.imshow(‘img’,img)
cv.waitKey(0)
cv.destroyAllWindows()

Listato 1

<opencv_storage>
<cascade type_id=”opencv-cascade-classifier”><stageType>BOOST</stageType>
<featureType>HAAR</featureType>
<height>24</height>
<width>24</width>
<stageParams>
<maxWeakCount>211</maxWeakCount></stageParams>
<featureParams>
<maxCatCount>0</maxCatCount></featureParams>
<stageNum>25</stageNum>
<stages>
<_>
<maxWeakCount>9</maxWeakCount>
<stageThreshold>-5.0425500869750977e+00</stageThreshold>
<weakClassifiers>
<_>
<internalNodes>
0 -1 0 -3.1511999666690826e-02</internalNodes>
<leafValues>
2.0875380039215088e+00 -2.2172100543975830e+00</leafValues></_>
<rects>
<_>
16 2 3 20 -1.</_>
<_>
17 2 1 20 3.</_></rects></_>
…
…
…

 

 

Rilevamento del sorriso con OpenCV 4

Adesso passiamo ad una semplice serie di istruzioni per ottenere il rilevamento del sorriso, effettuato analizzando un breve file video.
A questo scopo, serviranno i due classificatori:

haarcascade_frontalface_default.xml
haarcascade_smile.xml

Dopo aver caricato le librerie necessarie, vengono creati gli oggetti face_cascade e smile_cascade come spiegato prima. La funzione cv2.VideoCapture permette di caricare il filmato. Il nostro video demo si chiama ‘pier_smile.mp4’ ed è quello di un volto dapprima serio e poi sorridente. La risoluzione di cattura del video è di 640×480 e il fattore di scala (sF) è di 1.05.

import cv2
import numpy as np
import sys

face_cascade = cv2.CascadeClassifier(“haarcascade_frontalface_default.xml”)
smile_cascade = cv2.CascadeClassifier(“haarcascade_smile.xml”)

cap = cv2.VideoCapture(‘pier_smile.mp4’)
cap.set(3,640)
cap.set(4,480)
sF = 1.05

Il ciclo while analizza tutti i frame del video, trasformandoli in immagini a scala di grigi, esattamente come nell’esempio precedente. Vi facciamo notare che adesso l’oggetto img è un frame catturato di volta in volta dalla funzione cap.read().

while (cap.isOpened()):
ret, frame = cap.read()
img = frame
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

La funzione face_cascade.detectMultiScale cercherà nel video (meglio, in ogni frame) il volto…

faces = face_cascade.detectMultiScale(
gray,
scaleFactor= sF,
minNeighbors=8,
minSize=(55, 55),
flags=cv2.CASCADE_SCALE_IMAGE
)

…e, una volta trovato, creerà una regione di interesse attraverso le righe di codice:

for (x, y, w, h) in faces:
roi_gray = gray[y:y+h, x:x+w]
roi_color = frame[y:y+h, x:x+w]

La funzione smile_cascade.detectMultiScale cercherà un sorriso all’interno del volto…

smile = smile_cascade.detectMultiScale(
roi_gray,
scaleFactor= 1.7,
minNeighbors=22,
minSize=(25, 25),
flags=cv2.CASCADE_SCALE_IMAGE
)

…e una volta trovato, disegnerà un rettangolo intorno al sorriso, mentre nella finestra di terminale verrà stampato “Trovato un sorriso”.

for (x, y, w, h) in smile:
print(“Trovato un sorriso!”)
cv2.rectangle(roi_color, (x, y), (x+w, y+h), (255, 0, 0), 1)

Nella finestra “Smile Detector” si potrà vedere il risultato (Fig. 5). Se si preme il tasto ESC il programma viene terminato.

cv2.imshow(‘Smile Detector’, frame)
c = cv2.waitKey(7) % 0x100
if c == 27:
break
cap.release()
cv2.destroyAllWindows()

 

Riconoscimento facciale in tempo reale

Il terzo esperimento per il rilevamento facciale prevede l’uso di una normalissima webcam USB.

Come al solito, all’inizio dello script si importano le librerie necessarie e il classificatore haarcascade_frontalface_default.xml.

Con la funzione cv2.VideoCapture(0) vista prima è possibile catturare direttamente il video di una webcam USB passando il parametro 0.

import cv2
import sys
cascade_path = “haarcascade_frontalface_default.xml”
face_cascade = cv2.CascadeClassifier(cascade_path)
video_capture = cv2.VideoCapture(0)

Il ciclo while controlla che sia collegata una webcam e quindi esegue la cattura frame by frame. Come al solito tutti i frame vengono convertiti in scala di grigio.

while True:
if not video_capture.isOpened():
print(‘Unable to load camera.’)
pass
ret, frame = video_capture.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

La funzione face_cascade.detectMultiScale ricerca un volto nello streaming video (meglio ancora, in ogni frame) attraverso le istruzioni:

faces = face_cascade.detectMultiScale(
gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30)
)

…e disegna un rettangolo intorno al volto, quando viene trovato.

Tenete presente che con il parametro minSize=(30,30) è possibile rilevare volti anche molto piccoli o distanti dalla telecamera.

Per esempio, nella Fig. 6 potete vedere come venga catturata addirittura la foto della patente che il soggetto sta esibendo di fronte alla telecamera!

Le istruzioni che eseguono quanto spiegato sono le seguenti:

for (x, y, w, h) in faces:
cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)

Il risultato è visibile in una finestra chiamata “Video”, grazie alle istruzioni:

cv2.imshow(‘Video’, frame)
if cv2.waitKey(1) & 0xFF == ord(‘q’):
break
cv2.imshow(‘Video’, frame)
video_capture.release()
cv2.destroyAllWindows()

Premendo insieme i tasti CTRL+Q si termina il programma.

Notate che gli script Python haar_1.py, haar_2.py e haar3.py, i file XML, l’immagine e il video demo cui abbiamo fatto riferimento sono disponibili all’interno della cartella face_eye_detect. scaricabile dalla sezione download.

Download

Conclusioni

Bene, possiamo ritenere conclusa la trattazione. Termina qui, con questo progetto di riconoscimento facciale tramite Raspberry Pi, il nostro viaggio all’interno della libreria OpenCV 4, anche se ci sarebbe ancora molto da dire e si potrebbero proporre vari altri esempi applicativi; questo non è escluso perché in futuro ci piacerebbe continuare a pubblicare le nostre sperimentazioni con OpenCV 4, quindi continuate a seguirci.

Se volete approfondire l’utilizzo di Open CV4 Futura Academy mette a disposizione un corso specifico.