Baut e Gesiichtserkennungssystem baséiert op Golang an OpenCV

OpenCV ass eng Bibliothéik entwéckelt fir Computervisiounsprojeten. Si ass scho ronn 20 Joer aal. Ech hunn et an der Fachhéichschoul benotzt a benotzen se nach ëmmer fir meng C++ a Python Projeten well et gutt Ënnerstëtzung fir dës Sproochen huet.

Awer wéi ech ugefaang hunn ze léieren a Go ze benotzen, hunn ech mech interesséiert ob OpenCV ka benotzt ginn fir mat dëser Sprooch ze schaffen. Deemools gouf et scho Beispiller an Tutorials iwwer d'Integratioun, awer et huet mir geschéngt, datt se ze komplizéiert waren. E bësse méi spéit koum ech op e Wrapper erstallt vum The Hybrid Group Team. An dësem Artikel weisen ech Iech wéi Dir mat GoCV unzefänken andeems Dir en einfache Gesiichtserkennungssystem mat Haar Cascades entwéckelt.

Skillbox recommandéiert: Praktesch Cours "Python Entwéckler vun Null".

Mir erënneren Iech: fir all Habr Lieser - eng Remise vun 10 Rubel wann Dir Iech an all Skillbox Cours aschreift mat dem Habr Promo Code.

Wat ass néideg:

• Gitt;
• OpenCV (Installateur Linken ënnen);
• Web oder normale Videokamera.

Kader

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

Beispill 1

Am éischte Beispill wäerte mir probéieren eng Applikatioun ze kreéieren déi eng Fënster opmaacht déi e Kamera Video Stream weist.

Als éischt musst Dir d'Bibliothéiken importéieren déi néideg ass fir d'Aarbecht.

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

Duerno musst Dir e VideoCapture Objekt mat der VideoCaptureDevice Funktioun erstellen. Déi lescht mécht et méiglech e Videostream mat enger Kamera ze erfassen. D'Funktioun benotzt eng ganz Zuel als Parameter (et representéiert d'Apparat ID).

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

Elo musse mir eng n-dimensional Matrix kreéieren. Et späichert Biller gelies vun der Kamera.

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

Fir e Video Stream ze weisen, musst Dir eng Fënster erstellen - dëst kann mat der NewWindow Funktioun gemaach ginn.

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

Loosst eis elo op den interessantsten Deel goen.

Well Video e kontinuéierleche Stroum vu Bildframes ass, musse mir eng onendlech Loop erstellen fir endlos de Videostream vun der Kamera ze liesen. Fir dëst ze maachen, braucht Dir d'Liesmethod vum Typ VideoCapture. Et wäert e Mat Typ erwaarden (d'Matrix déi mir hei uewen erstallt hunn), e boolesche Wäert zréckzeginn, deen uginn ob de Frame vun der VideoCapture erfollegräich gelies gouf oder net.

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

Elo musst Dir de Frame an der erstallt Fënster weisen. D'Paus fir den nächste Frame ze plënneren ass 50 ms.

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

Nom Start vun der Applikatioun gëtt eng Fënster mat engem Videostream vun der Kamera op.

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

Beispill 2

An dësem Beispill, loosse d'virdrun Beispill benotzen an engem Gesiicht Unerkennung System baséiert op Haar Cascades bauen.

Haar Kaskaden si Kaskadeklasséierer déi mat der Haar Wavelet Technik trainéiert ginn. Si analyséieren d'Pixel an engem Bild fir verschidde Funktiounen z'entdecken. Fir méi iwwer Haar Cascades gewuer ze ginn, befollegt w.e.g. d'Links hei drënner.

Viola-Jones Objet Detectioun Kader
Cascading Klassifizéierer
Haar-wëll Fonktioun

Download schonn trainéiert Kaskaden kann hei sinn. Am aktuelle Beispill gi Kaskaden benotzt fir d'Gesiicht vun enger Persoun vu vir ze identifizéieren.

Fir dëst ze maachen, musst Dir e Klassifizéierer erstellen an et mat enger scho trainéierter Datei fidderen (de Link ass uewen uginn). Ech hunn d'Pencv_haarcascade_frontalface_default.xml Datei schonn an de Verzeechnes eropgelueden wou eise Programm läit.

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

Fir Gesiichter an engem Bild z'entdecken, musst Dir d'Method benotzen DetectMultiScale. Dës Funktioun hëlt e Frame (Typ Mat) dee just aus dem Videostroum vun der Kamera gelies gouf a gëtt eng Array vum Typ Rectangle zréck. D'Arraygréisst representéiert d'Zuel vun de Gesiichter, déi de Klassifizéierer konnt am Frame erkennen. Dann, fir sécherzestellen, datt mir gesinn wat et fonnt huet, loosst eis duerch d'Lëscht vu Rechtecker iteréieren an de Rectangle-Objet op d'Konsole drécken, an eng Grenz ronderëm de festgestallte Rechteck erstellen. Dëst kann mat der Rectangle Funktioun gemaach ginn. Et akzeptéiert d'Mat, déi vun der Kamera gelies gëtt, de Rectangle-Objet deen vun der DetectMultiScale-Methode zréckkoum, d'Faarf an d'Dicke fir d'Grenz.

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

An... jo, alles huet geklappt! Mir hunn elo en einfache Gesiichtserkennungssystem a Go geschriwwen. Geschwënn plangen ech dës Experimenter weiderzemaachen an nei cool Saachen ze kreéieren andeems ech Go an OpenCV kombinéiert.

Wann Dir interesséiert sidd, bewäert w.e.g gRPC Webserver, déi ech am Python an OpenCV geschriwwen hunn. Et streamt Daten de Moment wou e Gesiicht entdeckt gëtt. Dëst ass d'Basis fir verschidde Clienten a verschiddene Programméierungssproochen ze kreéieren. Si kënne mat dem Server konnektéieren an Daten dovunner liesen.

Merci fir d'Liesen vum Artikel!

Skillbox recommandéiert:

• Zwee-Joer praktesch Cours "Ech sinn e PRO Webentwéckler".
• Online pädagogesch Cours "Beruff Java Entwéckler".
• Praktesch ee Joer Cours "PHP Entwéckler vun 0 bis PRO".

Source: will.com