OpenCV è una libreria sviluppata per progetti di visione artificiale. Ha quasi 20 anni. L'ho utilizzata già al college e la utilizzo ancora per i miei progetti in C++ e Python, poiché offre un buon supporto per questi linguaggi.
Ma quando ho iniziato a studiare e utilizzare Go, mi è venuto in mente se fosse possibile applicare OpenCV a questo linguaggio. All'epoca esistevano già esempi e tutorial per l'integrazione, ma mi sembravano troppo complessi. Poco dopo ho trovato 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 i cascades di Haar.
Skillbox consiglia: Corso pratico .
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 il download qui sotto);
- una webcam o una normale videocamera.
Installazione
- Linux:
- macOS:
- Windows:
Esempio 1
Nel primo esempio cercheremo di creare un'applicazione che apre una finestra con una dimostrazione del flusso video dalla videocamera.
Per prima cosa è necessario importare le librerie necessarie.
import (
"log"
"gocv.io/x/gocv"
)
Dopo di che, è necessario creare un oggetto VideoCapture utilizzando la funzione VideoCaptureDevice. Quest'ultima consente di catturare il flusso video tramite la videocamera. Nella funzione viene utilizzato un numero intero come parametro (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 conterrà le immagini lette dalla videocamera.
img := gocv.NewMat()
defer img.Close()Per visualizzare il flusso video, è necessario creare una finestra — questo si può fare con la funzione NewWindow.
window := gocv.NewWindow("webcamwindow")
defer window.Close()Ora passiamo alla parte più interessante.
Poiché il video è un flusso continuo di fotogrammi-immagini, dovremo creare un ciclo infinito per la lettura continua del flusso video dalla videocamera. A tal fine, si utilizza il metodo Read del tipo VideoCapture. Questo attende un tipo Mat (la matrice che abbiamo creato sopra), restituendo un valore booleano che indica se il fotogramma è stato letto correttamente da VideoCapture o meno.
for {
if ok := webcam.Read(&img); !ok || img.Empty() {
log.Println("Impossibile leggere dalla webcam") continue
}
.
.
.
}Ora è necessario visualizzare il fotogramma nella finestra creata. La pausa per passare al fotogramma successivo è di 50 ms.
window.IMShow(img)
window.WaitKey(50)
Dopo aver avviato l'applicazione, si aprirà una finestra con il flusso video dalla videocamera.
package main
import (
"log"
"gocv.io/x/gocv"
)
func main() {
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil {
log.Fatalf("errore durante l'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.
Gli Haar Cascades sono classificatori a cascata addestrati sulla base della tecnica dei wavelet di Haar. Analizzano i pixel nell'immagine per rilevare determinate caratteristiche. Per saperne di più sugli Haar Cascades, puoi seguire i link qui sotto.
Scarica gli Haar Cascades già addestrati . Nell'esempio attuale, gli Haar Cascades verranno utilizzati per identificare il volto di una persona di fronte.
Per fare ciò, è necessario creare un classificatore e fornire un file già addestrato (il link è fornito sopra). Ho già caricato il file opencv_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 in un'immagine, è necessario utilizzare il metodo . Questa funzione accetta un fotogramma (tipo Mat), che è appena stato 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. Poi, per assicurarci di vedere ciò che ha trovato, esaminiamo l'elenco dei rettangoli e visualizziamo l'oggetto Rectangle sulla console, creando un contorno attorno al rettangolo rilevato. Questo può essere fatto con la funzione Rectangle. Essa accetterà Mat, letto dalla telecamera, un oggetto Rectangle restituibile dal metodo DetectMultiScale, il colore e lo spessore per il contorno.
for _, r := range rects {
fmt.Println("rilevato", 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("erro nell'aprire la webcam: %v", err)
}
defer webcam.Close()
img := gocv.NewMat()
defer img.Close()
window := gocv.NewWindow("finestradellacamera")
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 pianifico di continuare questi esperimenti e creare nuove cose interessanti, combinando Go e OpenCV.
Se ti interessa, valuta , che ho scritto in Python e OpenCV. Trasmette dati nel momento in cui viene rilevato un volto. Questa è la base per creare diversi client in vari linguaggi di programmazione. Potranno collegarsi al server e leggere i dati.
Grazie per aver letto l'articolo!
Skillbox consiglia:
- Corso pratico di due anni .
- Corso online educativo .
- Corso pratico annuale .
Fonte: habr.com
