Het bouwen van een gezichtsherkenningssysteem op basis van Golang en OpenCV

OpenCV is een bibliotheek ontworpen voor computer vision-projecten. Ze is al ongeveer 20 jaar oud. Ik gebruikte het op de universiteit en gebruik het nog steeds voor mijn C++- en Python-projecten omdat het goede ondersteuning biedt voor die talen.

Maar toen ik Go begon te leren en te gebruiken, raakte ik geïnteresseerd in de vraag of OpenCV gebruikt kon worden om met deze taal te werken. Destijds waren er al voorbeelden en tutorials over integratie, maar het leek mij dat ze te ingewikkeld waren. Even later kwam ik een verpakking tegen die was gemaakt door het team van The Hybrid Group. In dit artikel laat ik je zien hoe je aan de slag kunt gaan met GoCV door een eenvoudig gezichtsherkenningssysteem te ontwikkelen met Haar Cascades.

Skillbox beveelt aan: Praktische cursus "Python-ontwikkelaar vanaf nul".

Herinnering: voor alle lezers van "Habr" - een korting van 10 roebel bij inschrijving voor een Skillbox-cursus met behulp van de promotiecode "Habr".

Wat is vereist:

• Gaan;
• OpenCV (links naar installatieprogramma hieronder);
• web- of gewone videocamera.

installatie

• Linux: gocv.io/aan de slag/linux
• macOS: gocv.io/aan de slag/macos
• Windows: gocv.io/aan de slag/windows

voorbeeld 1

In het eerste voorbeeld proberen we een applicatie te maken die een venster opent met een cameravideostream.

Eerst moet u de bibliotheken importeren die nodig zijn voor uw werk.

importeren (
"loggen"
“gocv.io/x/gocv”
)

Hierna moet u een VideoCapture-object maken met behulp van de VideoCaptureDevice-functie. Dit laatste maakt het mogelijk om met een camera een videostream vast te leggen. De functie gebruikt een geheel getal als parameter (deze vertegenwoordigt de apparaat-ID).

webcam, err := gocv.VideoCaptureDevice(0)
if err != nil {    log.Fatalf(“error opening web cam: %v”, err)
}
defer webcam.Close()

Nu moeten we een n-dimensionale matrix creëren. Het slaat afbeeldingen op die van de camera zijn gelezen.

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

Om een ​​videostream weer te geven, moet u een venster maken. Dit kunt u doen met behulp van de NewWindow-functie.

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

Laten we nu verder gaan met het meest interessante deel.

Omdat video een continue stroom van beeldframes is, zullen we een oneindige lus moeten creëren om de videostream van de camera eindeloos te kunnen lezen. Hiervoor heeft u de Read-methode van het type VideoCapture nodig. Het verwacht een Mat-type (de matrix die we hierboven hebben gemaakt), die een Booleaanse waarde retourneert die aangeeft of het frame van VideoCapture succesvol is gelezen of niet.

for {     
        if ok := webcam.Read(&img); !ok || img.Empty( {
        log.Println(“Unable to read from the webcam”)    continue
     }
.
.
.
}

Nu moet u het frame in het gemaakte venster weergeven. De pauze voor het overgaan naar het volgende frame bedraagt ​​50 ms.

venster.IMShow(img)
venster.WaitKey(50)

Na het starten van de applicatie wordt een venster geopend met een videostream van de camera.

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)
}
}

voorbeeld 2

Laten we in dit voorbeeld het vorige voorbeeld gebruiken en een gezichtsherkenningssysteem bouwen op basis van Haar Cascades.

Haarcascades zijn cascadeclassificatoren die zijn getraind met behulp van de Haar wavelet-techniek. Ze analyseren de pixels in een afbeelding om bepaalde kenmerken te detecteren. Voor meer informatie over Haar Cascades kunt u de onderstaande links volgen.

Viola-Jones raamwerk voor objectdetectie
Trapsgewijze classificaties
Haarachtige eigenschap

Download reeds getrainde cascades kan hier zijn. In het huidige voorbeeld worden cascades gebruikt om het gezicht van een persoon vanaf de voorkant te identificeren.

Om dit te doen, moet u een classificator maken en deze aan een reeds getraind bestand toevoegen (de link vindt u hierboven). Ik heb het bestand pencv_haarcascade_frontalface_default.xml al geüpload naar de map waar ons programma zich bevindt.

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

Om gezichten in een afbeelding te detecteren, moet u de methode gebruiken Detecteer MultiScale. Deze functie neemt een frame (type Mat) dat zojuist uit de videostream van de camera is gelezen en retourneert een array van het type Rechthoek. De arraygrootte vertegenwoordigt het aantal gezichten dat de classificator in het frame heeft kunnen detecteren. Om er zeker van te zijn dat we zien wat het heeft gevonden, gaan we vervolgens door de lijst met rechthoeken en printen we een Rectangle-object naar de console, waarbij we een rand rond de gedetecteerde rechthoek creëren. Dit kan gedaan worden met behulp van de rechthoekfunctie. Het accepteert de mat die door de camera is gelezen, het rechthoekobject dat is geretourneerd door de DetectMultiScale-methode, de kleur en dikte van de rand.

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)
}
}

En... ja, alles is gelukt! We hebben nu een eenvoudig gezichtsherkenningssysteem geschreven in Go. Binnenkort ben ik van plan deze experimenten voort te zetten en nieuwe coole dingen te creëren door Go en OpenCV te combineren.

Als u geïnteresseerd bent, kunt u een beoordeling geven gRPC-webserver, die ik schreef in Python en OpenCV. Het streamt gegevens zodra een gezicht wordt gedetecteerd. Dit is de basis voor het maken van verschillende clients in verschillende programmeertalen. Ze kunnen verbinding maken met de server en er gegevens van lezen.

Bedankt voor het lezen van het artikel!

Skillbox beveelt aan:

• Tweejarige praktijkopleiding "Ik ben een PRO-webontwikkelaar".
• Educatieve online cursus "Beroep Java-ontwikkelaar".
• Praktische jaarcursus "PHP-ontwikkelaar van 0 tot PRO".

Bron: www.habr.com