Costruiamo un sistema di riconoscimento facciale basato su Golang e OpenCV

OpenCV — una biblioteca sviluppata per progetti di visione artificiale. Ha circa 20 anni. L'ho utilizzata già al college e continuo a farne uso nei miei progetti in C++ e Python, poiché offre un buon supporto per questi linguaggi.

Ma quando ho iniziato a studiare e utilizzare Go, mi sono chiesto se fosse possibile usare OpenCV con questo linguaggio. All'epoca esistevano già esempi e tutorial sull'integrazione, ma mi sembravano troppo complessi. Poco dopo, sono venuto a conoscenza di un wrapper creato dal team di The Hybrid Group. In questo articolo mostrerò come iniziare con GoCV, sviluppando un semplice sistema di riconoscimento facciale utilizzando le Haar Cascades.

Skillbox consiglia: Corso pratico «Sviluppatore Python da zero».

Ricordiamo: per tutti i lettori di «Habr» — sconto di 10.000 rubli per l'iscrizione a qualsiasi corso Skillbox con il codice promozionale «Habr».

Cosa serve:

• Go;
• OpenCV (link per l'installer qui sotto);
• una webcam o una videocamera normale.

Installazione

• Linux: gocv.io/getting-started/linux
• macOS: gocv.io/getting-started/macos
• Windows: gocv.io/getting-started/windows

Esempio 1

Nel primo esempio proveremo a creare un'applicazione che apre una finestra per dimostrare il flusso video della camera.

Inizialmente bisogna importare le librerie necessarie per il funzionamento.

import (
"log"
"gocv.io/x/gocv"
)

Dopo di ciò, è necessario creare un oggetto VideoCapture utilizzando la funzione VideoCaptureDevice. Quest'ultima consente di acquisire il flusso video tramite la fotocamera. Nella funzione si utilizza un intero come parametro (che rappresenta l'ID del dispositivo).

webcam, err := gocv.VideoCaptureDevice(0)
if err != nil { log.Fatalf("errore nell'apertura della webcam: %v", err)
}
defer webcam.Close()

Ora è necessario creare una matrice n-dimensionale. Essa conserverà le immagini lette dalla fotocamera.

img := gocv.NewMat()
defer img.Close()

Per visualizzare il flusso video, è necessario creare una finestra — ciò può essere fatto utilizzando la funzione NewWindow.

window := gocv.NewWindow("webcamwindow")
defer window.Close()

Ora passiamo alla parte più interessante.

Poiché il video rappresenta un flusso continuo di fotogrammi-immagini, sarà necessario creare un ciclo infinito per leggere continuativamente il flusso video della fotocamera. A tal fine, è necessario il metodo Read del tipo VideoCapture. Questo aspetterà un tipo Mat (la matrice che abbiamo creato sopra), restituendo un valore booleano che indica se il fotogramma è stato letto con successo oppure no.

for { 
 if ok := webcam.Read(&img); !ok || img.Empty() {
 log.Println("Impossibile leggere dalla webcam") continue
 }
.
.
.
}

Ora è necessario visualizzare il frame nella finestra creata. Pausa per passare al prossimo frame — 50 ms.

window.IMShow(img)
window.WaitKey(50)

Una volta avviata l'applicazione, si aprirà una finestra con il flusso video dalla fotocamera.

package main
 
import (
"log"
 
"gocv.io/x/gocv"
)
 
func main() {
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil {
    log.Fatalf("errore nell'apertura del dispositivo: %v", err)
}
defer webcam.Close()
 
img := gocv.NewMat()
defer img.Close()
 
window := gocv.NewWindow("webcamwindow")
defer window.Close()
 
for {
if ok := webcam.Read(&img); !ok || img.Empty() {
log.Println("Impossibile leggere dalla webcam")
continue
}
 
window.IMShow(img)
window.WaitKey(50)
}
}

Esempio 2

In questo esempio, utilizziamo l'esempio precedente per costruire un sistema di riconoscimento facciale basato su Haar Cascades.

Le Haar Cascades sono classificatori a cascata addestrati utilizzando la tecnica delle wavelet Haar. Esse analizzano i pixel dell'immagine per rilevare determinate caratteristiche. Per saperne di più sulle Haar Cascades, puoi seguire i link qui sotto.

Framework di rilevamento oggetti Viola-Jones
Classificatori a cascata
Caratteristiche simili a Haar

Scarica cascades già addestrati qui. Nel presente esempio, le cascades verranno utilizzate per identificare il volto di una persona di fronte.

Per fare questo, è necessario creare un classificatore e fornirgli un file già addestrato (il link è fornito qui sopra). Ho già caricato il file pencv_haarcascade_frontalface_default.xml nella directory in cui si trova il nostro programma.

harrcascade := "opencv_haarcascade_frontalface_default.xml"classifier := gocv.NewCascadeClassifier()classifier.Load(harrcascade)
defer classifier.Close()

Per rilevare i volti nell'immagine, è necessario utilizzare il metodo DetectMultiScale. Questa funzione prende un fotogramma (tipo Mat), che è stato appena letto dal flusso video della telecamera, e restituisce un array di tipo Rectangle. La dimensione dell'array rappresenta il numero di volti che il classificatore è riuscito a rilevare nel fotogramma. Quindi, per assicurarci di vedere ciò che ha trovato, attraversiamo l'elenco dei rettangoli e visualizziamo l'oggetto Rectangle sulla console, creando un bordo attorno al rettangolo rilevato. Questo può essere fatto utilizzando la funzione Rectangle. Essa accetterà Mat, letto dalla telecamera, oggetto Rectangle restituito dal metodo DetectMultiScale, colore e spessore per il bordo.

for _, r := range rects {
fmt.Println("detected", r)
gocv.Rectangle(&img, r, color, 2)
}

package main
 
import (
"fmt"
"image/color"
"log"
 
"gocv.io/x/gocv"
)
 
func main() {
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil {
log.Fatalf("errore nell'aprire la webcam: %v", err)
}
defer webcam.Close()
 
img := gocv.NewMat()
defer img.Close()
 
window := gocv.NewWindow("finestrawecam")
defer window.Close()
 
harrcascade := "opencv_haarcascade_frontalface_default.xml"
classifier := gocv.NewCascadeClassifier()
classifier.Load(harrcascade)
defer classifier.Close()
 
color := color.RGBA{0, 255, 0, 0}
for {
if ok := webcam.Read(&img); !ok || img.Empty() {
log.Println("Impossibile leggere dal dispositivo")
continue
}
 
rects := classifier.DetectMultiScale(img)
for _, r := range rects {
fmt.Println("rilevato", r)
gocv.Rectangle(&img, r, color, 3)
}
 
window.IMShow(img)
window.WaitKey(50)
}
}

E... sì, ce l'abbiamo fatta! Ora abbiamo un semplice sistema di riconoscimento facciale scritto in Go. Presto intendo continuare questi esperimenti e creare cose nuove e interessanti combinando Go e OpenCV.

Se siete interessati, vi invito a dare un'occhiata server web gRPC, che ho scritto in Python e OpenCV. Esegue lo streaming dei dati al momento del riconoscimento del volto. Questa è la base per creare diversi client in vari linguaggi di programmazione. Possono collegarsi al server e leggere i dati.

Grazie per aver letto l'articolo!

Skillbox consiglia:

• Corso pratico di due anni «Sono uno sviluppatore web PRO».
• Corso online educativo «Professione Sviluppatore Java».
• Corso pratico annuale «Sviluppatore PHP da 0 a PRO».

Fonte: habr.com