Vi bygger ett ansiktigenkänningssystem baserat på Golang och OpenCV

OpenCV är ett bibliotek som utvecklats för projekt inom datorseende. Det har nu funnits i ungefär 20 år. Jag använde det redan på universitetet och använder det fortfarande för mina projekt i C++ och Python, eftersom det har ett bra stöd för dessa språk.

Men när jag började utforska och använda Go blev jag nyfiken på om man kunde använda OpenCV med detta språk. Det fanns redan exempel och tutorials för integration vid det tillfället, men jag tyckte att de var för komplicerade. Lite senare kom jag i kontakt med en wrapper som skapats av teamet på The Hybrid Group. I den här artikeln kommer jag att visa hur man börjar med GoCV genom att utveckla ett enkelt ansiktsigenkänningssystem med Haar Cascades.

Skillbox rekommenderar: Praktisk kurs «Python-utvecklare från grunden».

Påminnelse: för alla läsare av "Habr" — 10 000 rubel rabatt vid registrering för vilken kurs som helst på Skillbox med rabattkoden "Habr".

Vad som behövs:

• Go;
• OpenCV (länkar till installerare nedan);
• en webbkamera eller vanlig kamera.

Installation

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

Exempel 1

I det första exemplet kommer vi att försöka skapa en applikation som öppnar ett fönster med en demonstration av videoströmmen från kameran.

Först måste vi importera de bibliotek som behövs för att arbeta.

import (
“log”
“gocv.io/x/gocv”
)

Därefter behöver vi skapa ett VideoCapture-objekt med hjälp av funktionen VideoCaptureDevice. Denna ger oss möjlighet att fånga videoströmmen med hjälp av kameran. Funktionen använder ett heltal som parameter (det representerar enhetens ID).

webcam, err := gocv.VideoCaptureDevice(0)
if err != nil {    log.Fatalf(“fel vid öppning av webbkameran: %v”, err)
}
defer webcam.Close()

Nu behöver vi skapa en n-dimensionell matris. Den kommer att lagra bilder som läses in från kameran.

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

För att visa videoströmmen behöver vi skapa ett fönster — detta kan göras med funktionen NewWindow.

window := gocv.NewWindow(“webcamwindow”)
defer window.Close()

Nu går vi vidare till den mest intressanta delen.

Eftersom videon är en kontinuerlig ström av bildrutor behöver vi skapa en oändlig loop för att kontinuerligt läsa videoströmmen från kameran. För detta behövs metoden Read av typen VideoCapture. Den kommer att förvänta sig en typ Mat (matrisen vi skapade ovan), och returnera ett booleskt värde som indikerar om en bildruta från VideoCapture har lästs in framgångsrikt eller inte.

for {     
        if ok := webcam.Read(&img); !ok || img.Empty() {
        log.Println(“Kunde inte läsa från webbkameran”)    continue
     }
.
.
.
}

Nu behöver vi visa ramen i det skapade fönstret. Paus för att gå till nästa ram — 50 ms.

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

När applikationen körs öppnas ett fönster med videoströmmen från kameran.

package main
 
import (
"log"
 
"gocv.io/x/gocv"
)
 
func main() {
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil {
    log.Fatalf("error opening device: %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("Unable to read from the webcam")
continue
}
 
window.IMShow(img)
window.WaitKey(50)
}
}

Exempel 2

I det här exemplet ska vi använda det föregående exemplet och bygga ett system för ansiktsigenkänning baserat på Haar Cascades.

Haar Cascades är kaskadklassificerare som tränas med hjälp av Haar-vågletetekniken. De analyserar pixlar i en bild för att upptäcka specifika funktioner. För att lära dig mer om Haar Cascades kan du följa länkarna nedan.

Viola-Jones objektidentifieringsramverk
Kaskadklassificerare
Haar-liknande funktion

Ladda ner redan tränade kaskader här. I det aktuella exemplet kommer kaskaderna att användas för att identifiera ett ansikte på en person i frontprofil.

För att göra detta måste du skapa en klassificerare och mata den med en redan tränad fil (länken ovan ger mer information). Jag har redan laddat upp filen opencv_haarcascade_frontalface_default.xml i katalogen där vårt program finns.

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

För att upptäcka ansikten i en bild måste du använda metoden DetectMultiScale. Denna funktion tar en bild (typ Mat) som just har lästs in från kamerans videoström och returnerar en array av typen Rectangle. Storleken på arrayen representerar antalet ansikten som klassificeraren kunde upptäcka i bilden. För att se att vi faktiskt ser vad den har upptäckt, låt oss gå igenom listan av rektanglar och skriva ut objektet Rectangle på konsolen genom att skapa en kant runt den upptäckta rektangeln. Detta kan göras med hjälp av funktionen Rectangle. Den tar Mat, som lästs in av kameran, objektet Rectangle som returnerades av metoden DetectMultiScale, färgen och tjockleken för kanten.

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("error opening web cam: %v", err)
}
defer webcam.Close()
 
img := gocv.NewMat()
defer img.Close()
 
window := gocv.NewWindow("webcamwindow")
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("Unable to read from the device")
continue
}
 
rects := classifier.DetectMultiScale(img)
for _, r := range rects {
fmt.Println("detected", r)
gocv.Rectangle(&img, r, color, 3)
}
 
window.IMShow(img)
window.WaitKey(50)
}
}

Och ja, det blev bra! Nu har vi ett enkelt system för ansiktsigenkänning skrivet i Go. Snart planerar jag att fortsätta med dessa experiment och skapa nya coola grejer genom att kombinera Go och OpenCV.

Om du är intresserad, ge en bedömning gRPC web server, som jag skrev i Python och OpenCV. Den strämmar data i realtid när den upptäcker ett ansikte. Detta är grunden för att skapa olika klienter på olika programmeringsspråk. De kommer att kunna ansluta till servern och läsa data från den.

Tack för att du läste artikeln!

Skillbox rekommenderar:

• Tvåårig praktisk kurs «Jag är webbutvecklare PRO».
• Utbildningskurs online "Yrket Java-utvecklare".
• Praktisk årskurs PHP-utvecklare från grunden till PRO.

Källa: habr.com