Rilevamento facciale con Python usando OpenCV

Introduzione ai classificatori Haar Cascade

Questo metodo è stato introdotto per la prima volta nell'articolo Rapid Object Detection Using a Boosted Cascade of Simple Features, scritto da Paul Viola e Michael Jones.

L'idea alla base di questa tecnica consiste nell'usare una cascata di classificatori per rilevare diverse caratteristiche in un'immagine. Questi classificatori vengono poi combinati in un unico classificatore forte in grado di distinguere con precisione i campioni che contengono un volto umano da quelli che non lo contengono.

Il classificatore Haar Cascade integrato in OpenCV è già stato addestrato su un ampio dataset di volti umani, quindi non è richiesto ulteriore training. Ci basta caricare il classificatore dalla libreria e usarlo per eseguire il rilevamento facciale su un'immagine di input.

Installare OpenCV per Python

Per installare la libreria OpenCV, apri semplicemente il prompt dei comandi o il terminale ed esegui il seguente comando:

pip install opencv-python

Questo comando funziona solo se hai già installato pip sul tuo dispositivo. Se vuoi saperne di più sul gestore di pacchetti pip, puoi leggere il nostro PIP Python Tutorial.

OpenCV per il rilevamento facciale nelle immagini

Costruiremo un rilevatore per identificare il volto umano in una foto da Unsplash. Assicurati di salvare l'immagine nella tua directory di lavoro e rinominarla in input_image prima di seguire il codice.

Passaggio 1: importa il pacchetto OpenCV

Ora importiamo OpenCV e inseriamo il percorso dell'immagine di input con le seguenti righe di codice:

import cv2

imagePath = 'input_image.jpg'

Passaggio 2: leggi l'immagine

Quindi dobbiamo leggere l'immagine con la funzione imread() di OpenCV:

img = cv2.imread(imagePath)

Questo caricherà l'immagine dal percorso di file specificato e la restituirà sotto forma di array Numpy. 

Stampiamo le dimensioni di questo array:

img.shape

(4000, 2667, 3)

Nota che si tratta di un array tridimensionale. I valori dell'array rappresentano rispettivamente l'altezza, la larghezza e i canali dell'immagine. Poiché questa è un'immagine a colori, ci sono tre canali utilizzati per rappresentarla: blu, verde e rosso (BGR). 

Tieni presente che, mentre la sequenza convenzionale usata per rappresentare le immagini è RGB (Red, Green, Blue), la libreria OpenCV usa il layout opposto (Blue, Green, Red).

Passaggio 3: converti l'immagine in scala di grigi

Per migliorare l'efficienza computazionale, dobbiamo prima convertire l'immagine in scala di grigi prima di eseguire il rilevamento facciale:

gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

Esaminiamo ora le dimensioni di questa immagine in scala di grigi:

gray_image.shape

(4000, 2667)

Nota che questo array ha solo due valori poiché l'immagine è in scala di grigi e non ha più il terzo canale colore.

Passaggio 4: carica il classificatore

Carichiamo il classificatore Haar Cascade pre-addestrato integrato in OpenCV:

face_classifier = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)

Nota che stiamo usando un file chiamato haarcascade_frontalface_default.xml. Questo classificatore è progettato specificamente per rilevare volti frontali nell'input visivo. 

OpenCV fornisce anche altri modelli pre-addestrati per rilevare diversi oggetti all'interno di un'immagine, come gli occhi di una persona, il sorriso, la parte superiore del corpo e persino la targa di un veicolo. Puoi saperne di più sui diversi classificatori integrati in OpenCV consultando il repository GitHub della libreria.

Passaggio 5: esegui il rilevamento facciale

Ora possiamo eseguire il rilevamento facciale sull'immagine in scala di grigi usando il classificatore appena caricato:

face = face_classifier.detectMultiScale(
    gray_image, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40)
)

Analizziamo i metodi e i parametri specificati nel codice sopra:

1. detectMultiScale():

Il metodo detectMultiScale() è usato per identificare volti di dimensioni diverse nell'immagine di input.

1. grey_image:

Il primo parametro di questo metodo si chiama grey_image, ovvero l'immagine in scala di grigi che abbiamo creato in precedenza.

1. scaleFactor:

Questo parametro viene usato per ridurre la dimensione dell'immagine di input per facilitare all'algoritmo il rilevamento dei volti più grandi. In questo caso abbiamo specificato un fattore di scala pari a 1,1, indicando che vogliamo ridurre la dimensione dell'immagine del 10%.

1. minNeighbors:

Il classificatore a cascata applica una finestra scorrevole sull'immagine per rilevarvi i volti. Puoi pensare a queste finestre come a rettangoli. 

Inizialmente, il classificatore catturerà un gran numero di falsi positivi. Questi vengono eliminati usando il parametro minNeighbors, che specifica il numero di rettangoli adiacenti che devono essere identificati perché un oggetto sia considerato un rilevamento valido.

In sintesi, passare un valore piccolo come 0 o 1 a questo parametro produrrebbe un alto numero di falsi positivi, mentre un valore grande potrebbe portare a perdere molti veri positivi.

Il trucco sta nel trovare un compromesso che ci permetta di eliminare i falsi positivi e allo stesso tempo identificare accuratamente i veri positivi.

1. minSize:

Infine, il parametro minSize imposta la dimensione minima dell'oggetto da rilevare. Il modello ignorerà i volti più piccoli della dimensione minima specificata.

Passaggio 6: disegnare un riquadro di delimitazione

Ora che il modello ha rilevato i volti nell'immagine, eseguiamo le seguenti righe di codice per creare un riquadro di delimitazione attorno a questi volti:

for (x, y, w, h) in face:
    cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 4)

La variabile face è un array con quattro valori: gli assi x e y in cui sono stati rilevati i volti e la loro larghezza e altezza. Il codice sopra itera sui volti identificati e crea un riquadro che copre queste misure.

Il parametro 0,255,0 rappresenta il colore del riquadro, che è verde, e 4 ne indica lo spessore.

Passaggio 7: visualizzare l'immagine

Per visualizzare l'immagine con i volti rilevati, dobbiamo prima convertire l'immagine dal formato BGR a RGB:

img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

Ora usiamo la libreria Matplotlib per mostrare l'immagine:

import matplotlib.pyplot as plt



plt.figure(figsize=(20,10))
plt.imshow(img_rgb)
plt.axis('off')

Il codice sopra dovrebbe generare il seguente output: 

Ottimo!

Il modello ha rilevato correttamente il volto umano in questa immagine e ha creato un riquadro attorno ad esso. 

Rilevamento facciale in tempo reale con OpenCV

Ora che abbiamo eseguito con successo il rilevamento facciale su un'immagine statica con OpenCV, vediamo come fare lo stesso su uno stream video live. 

Passaggio 1: prerequisiti

Per prima cosa, importiamo la libreria OpenCV e carichiamo il modello Haar Cascade proprio come nella sezione precedente. Puoi saltare questo blocco di codice se lo hai già eseguito prima:

import cv2

face_classifier = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)

Passaggio 2: accedi alla webcam

Ora dobbiamo accedere alla fotocamera del nostro dispositivo per leggere un flusso video live. Questo si può fare con il seguente codice:

video_capture = cv2.VideoCapture(0)

Nota che abbiamo passato il parametro 0 alla funzione VideoCapture(). Questo indica a OpenCV di usare la fotocamera predefinita del dispositivo. Se hai più fotocamere collegate al dispositivo, puoi modificare di conseguenza il valore di questo parametro.

Passaggio 3: identificare i volti nello stream video

Ora creiamo una funzione per rilevare i volti nello stream video e disegnare un riquadro attorno ad essi:

def detect_bounding_box(vid):
    gray_image = cv2.cvtColor(vid, cv2.COLOR_BGR2GRAY)
    faces = face_classifier.detectMultiScale(gray_image, 1.1, 5, minSize=(40, 40))
    for (x, y, w, h) in faces:
        cv2.rectangle(vid, (x, y), (x + w, y + h), (0, 255, 0), 4)
    return faces

La funzione detect_bounding_box prende come input il frame video.

In questa funzione stiamo usando lo stesso codice visto prima per convertire il frame in scala di grigi prima di eseguire il rilevamento facciale.

Quindi rileviamo il volto in questa immagine usando gli stessi valori dei parametri scaleFactor, minNeighbors e minSize di prima.

Infine, disegniamo un riquadro verde di spessore 4 attorno al frame.

Passaggio 4: creare un loop per il rilevamento facciale in tempo reale

Ora dobbiamo creare un ciclo while indefinito che catturi il frame video dalla webcam e applichi la funzione di rilevamento facciale:

while True:

    result, video_frame = video_capture.read()  # read frames from the video
    if result is False:
        break  # terminate the loop if the frame is not read successfully

    faces = detect_bounding_box(
        video_frame
    )  # apply the function we created to the video frame

    cv2.imshow(
        "My Face Detection Project", video_frame
    )  # display the processed frame in a window named "My Face Detection Project"

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

video_capture.release()
cv2.destroyAllWindows()

Dopo aver eseguito il codice sopra, dovresti vedere apparire sullo schermo una finestra chiamata My Face Detection Project:

L'algoritmo dovrebbe tracciare il tuo volto e creare un riquadro verde attorno ad esso, indipendentemente da dove ti muovi all'interno del frame.

Nel frame sopra, il modello riconosce il mio volto e la mia foto sulla patente che sto tenendo in mano.

Puoi anche testare l'efficacia di questo modello mostrando più immagini o facendo posizionare persone diverse a varie angolazioni davanti alla fotocamera. Il modello dovrebbe essere in grado di identificare tutti i volti umani in contesti o condizioni di illuminazione differenti.

Se vuoi uscire dal programma, puoi premere il tasto “q” sulla tastiera per interrompere il ciclo.

Conclusione

In conclusione, OpenCV è una libreria potente e versatile per creare applicazioni di computer vision, che offre un'ampia gamma di modelli pre-addestrati e strumenti per semplificare compiti complessi come il rilevamento facciale.

Che tu stia elaborando immagini statiche o stream video live, OpenCV fornisce un punto di ingresso accessibile per sviluppare soluzioni efficienti e scalabili.

Apprendendo le tecniche trattate in questo tutorial, sarai pronto a esplorare applicazioni più avanzate della computer vision nei tuoi progetti.