ప్రోహోస్టర్ > బ్లాగ్ > ఇంటర్నెట్ వార్తలు > గోలాంగ్ మరియు ఓపెన్‌సివి ఆధారంగా ముఖ గుర్తింపు వ్యవస్థను రూపొందించడం

గోలాంగ్ మరియు ఓపెన్‌సివి ఆధారంగా ముఖ గుర్తింపు వ్యవస్థను రూపొందించడం

గోలాంగ్ మరియు ఓపెన్‌సివి ఆధారంగా ముఖ గుర్తింపు వ్యవస్థను రూపొందించడం
OpenCV అనేది కంప్యూటర్ విజన్ ప్రాజెక్ట్‌ల కోసం రూపొందించబడిన లైబ్రరీ. అప్పటికే ఆమె వయసు దాదాపు 20 ఏళ్లు. నేను దీన్ని కాలేజీలో ఉపయోగించాను మరియు ఇప్పటికీ నా C++ మరియు పైథాన్ ప్రాజెక్ట్‌ల కోసం ఉపయోగిస్తున్నాను ఎందుకంటే ఆ భాషలకు మంచి మద్దతు ఉంది.

కానీ నేను గో నేర్చుకోవడం మరియు ఉపయోగించడం ప్రారంభించినప్పుడు, ఈ భాషతో పనిచేయడానికి OpenCVని ఉపయోగించవచ్చా అనే దానిపై నాకు ఆసక్తి కలిగింది. ఆ సమయంలో, ఇంటిగ్రేషన్‌పై ఇప్పటికే ఉదాహరణలు మరియు ట్యుటోరియల్‌లు ఉన్నాయి, కానీ అవి చాలా క్లిష్టంగా ఉన్నాయని నాకు అనిపించింది. కొద్దిసేపటి తర్వాత, నేను హైబ్రిడ్ గ్రూప్ బృందం సృష్టించిన రేపర్‌ని చూశాను. ఈ ఆర్టికల్‌లో, హార్ క్యాస్‌కేడ్స్‌తో సాధారణ ముఖ గుర్తింపు వ్యవస్థను అభివృద్ధి చేయడం ద్వారా GoCVని ఎలా ప్రారంభించాలో నేను మీకు చూపుతాను.

Skillbox సిఫార్సు చేస్తోంది: ప్రాక్టికల్ కోర్సు "మొదటి నుండి పైథాన్ డెవలపర్".

మేము గుర్తు చేస్తున్నాము: Habr పాఠకులందరికీ - Habr ప్రోమో కోడ్‌ని ఉపయోగించి ఏదైనా Skillbox కోర్సులో నమోదు చేసుకున్నప్పుడు 10 రూబుల్ తగ్గింపు.

ఏమి అవసరం:

  • వెళ్ళండి;
  • OpenCV (క్రింద ఇన్‌స్టాలర్ లింక్‌లు);
  • వెబ్ లేదా సాధారణ వీడియో కెమెరా.

సెట్టింగ్

ఉదాహరణకు 1

మొదటి ఉదాహరణలో, మేము కెమెరా వీడియో స్ట్రీమ్‌ను చూపించే విండోను తెరిచే అప్లికేషన్‌ను రూపొందించడానికి ప్రయత్నిస్తాము.

మొదట మీరు పని కోసం అవసరమైన లైబ్రరీలను దిగుమతి చేసుకోవాలి.

దిగుమతి (
"లాగ్"
"gocv.io/x/gocv"
)

దీని తర్వాత, మీరు VideoCaptureDevice ఫంక్షన్‌ని ఉపయోగించి వీడియో క్యాప్చర్ ఆబ్జెక్ట్‌ని సృష్టించాలి. రెండోది కెమెరాను ఉపయోగించి వీడియో స్ట్రీమ్‌ను క్యాప్చర్ చేయడాన్ని సాధ్యం చేస్తుంది. ఫంక్షన్ పూర్ణాంకాన్ని పారామీటర్‌గా ఉపయోగిస్తుంది (ఇది పరికరం IDని సూచిస్తుంది).

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

ఇప్పుడు మనం n-డైమెన్షనల్ మ్యాట్రిక్స్‌ని సృష్టించాలి. ఇది కెమెరా నుండి చదివిన చిత్రాలను నిల్వ చేస్తుంది.

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

వీడియో స్ట్రీమ్‌ను ప్రదర్శించడానికి, మీరు విండోను సృష్టించాలి - ఇది NewWindow ఫంక్షన్‌ని ఉపయోగించి చేయవచ్చు.

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

ఇప్పుడు అత్యంత ఆసక్తికరమైన భాగానికి వెళ్దాం.

వీడియో అనేది ఇమేజ్ ఫ్రేమ్‌ల యొక్క నిరంతర స్ట్రీమ్ కాబట్టి, కెమెరా యొక్క వీడియో స్ట్రీమ్‌ను అనంతంగా చదవడానికి మనం అనంతమైన లూప్‌ని సృష్టించాలి. దీన్ని చేయడానికి, మీకు VideoCapture రకం రీడ్ పద్ధతి అవసరం. ఇది వీడియో క్యాప్చర్ నుండి ఫ్రేమ్ విజయవంతంగా రీడ్ చేయబడిందా లేదా అనే విషయాన్ని సూచించే బూలియన్ విలువను తిరిగి ఇచ్చే మ్యాట్ రకాన్ని (మేము పైన సృష్టించిన మ్యాట్రిక్స్) ఆశిస్తుంది.

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

ఇప్పుడు మీరు సృష్టించిన విండోలో ఫ్రేమ్ను ప్రదర్శించాలి. తదుపరి ఫ్రేమ్‌కి వెళ్లడానికి పాజ్ 50 ms.

window.IMShow(img)
విండో.వెయిట్‌కీ(50)

అప్లికేషన్‌ను ప్రారంభించిన తర్వాత, కెమెరా నుండి వీడియో స్ట్రీమ్ ఉన్న విండో తెరవబడుతుంది.

గోలాంగ్ మరియు ఓపెన్‌సివి ఆధారంగా ముఖ గుర్తింపు వ్యవస్థను రూపొందించడం

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

ఉదాహరణకు 2

ఈ ఉదాహరణలో, మునుపటి ఉదాహరణను ఉపయోగిస్తాము మరియు హార్ క్యాస్కేడ్‌ల ఆధారంగా ముఖ గుర్తింపు వ్యవస్థను రూపొందించండి.

హార్ క్యాస్కేడ్‌లు హార్ వేవ్‌లెట్ టెక్నిక్‌ని ఉపయోగించి శిక్షణ పొందిన క్యాస్కేడ్ వర్గీకరణలు. వారు నిర్దిష్ట లక్షణాలను గుర్తించడానికి చిత్రంలోని పిక్సెల్‌లను విశ్లేషిస్తారు. హార్ క్యాస్కేడ్స్ గురించి మరింత తెలుసుకోవడానికి, దయచేసి దిగువ లింక్‌లను అనుసరించండి.

వయోలా-జోన్స్ ఆబ్జెక్ట్ డిటెక్షన్ ఫ్రేమ్‌వర్క్
క్యాస్కేడింగ్ వర్గీకరణదారులు
హార్ లాంటి లక్షణం

ఇప్పటికే శిక్షణ పొందిన క్యాస్కేడ్‌లను డౌన్‌లోడ్ చేయండి ఇక్కడ ఉండవచ్చు. ప్రస్తుత ఉదాహరణలో, ఒక వ్యక్తి ముఖాన్ని ముందు నుండి గుర్తించడానికి క్యాస్కేడ్‌లు ఉపయోగించబడతాయి.

దీన్ని చేయడానికి, మీరు వర్గీకరణను సృష్టించి, ఇప్పటికే శిక్షణ పొందిన ఫైల్‌ను అందించాలి (లింక్ పైన ఇవ్వబడింది). నేను ఇప్పటికే pencv_haarcascade_frontalface_default.xml ఫైల్‌ని మా ప్రోగ్రామ్ ఉన్న డైరెక్టరీకి అప్‌లోడ్ చేసాను.

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

చిత్రంలో ముఖాలను గుర్తించడానికి, మీరు పద్ధతిని ఉపయోగించాలి మల్టీస్కేల్‌ని గుర్తించండి. ఈ ఫంక్షన్ కెమెరా యొక్క వీడియో స్ట్రీమ్ నుండి ఇప్పుడే చదవబడిన ఫ్రేమ్ (రకం మ్యాట్)ని తీసుకుంటుంది మరియు దీర్ఘచతురస్ర రకం శ్రేణిని అందిస్తుంది. శ్రేణి పరిమాణం ఫ్రేమ్‌లో వర్గీకరణదారు గుర్తించగలిగిన ముఖాల సంఖ్యను సూచిస్తుంది. ఆ తర్వాత, అది కనుగొనబడిన వాటిని మనం చూసేందుకు, దీర్ఘచతురస్రాల జాబితా ద్వారా మళ్లిద్దాము మరియు దీర్ఘచతురస్ర వస్తువును కన్సోల్‌కు ప్రింట్ చేద్దాం, కనుగొనబడిన దీర్ఘచతురస్రం చుట్టూ సరిహద్దును సృష్టిద్దాం. ఇది దీర్ఘచతురస్ర ఫంక్షన్ ఉపయోగించి చేయవచ్చు. ఇది కెమెరా ద్వారా చదవబడిన మ్యాట్, DetectMultiScale పద్ధతి ద్వారా తిరిగి వచ్చిన దీర్ఘచతురస్రాకార వస్తువు, సరిహద్దు కోసం రంగు మరియు మందాన్ని అంగీకరిస్తుంది.

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

మరియు ... అవును, ప్రతిదీ పని చేసింది! మేము ఇప్పుడు గోలో వ్రాసిన సాధారణ ముఖ గుర్తింపు వ్యవస్థను కలిగి ఉన్నాము. త్వరలో నేను ఈ ప్రయోగాలను కొనసాగించాలనుకుంటున్నాను మరియు Go మరియు OpenCVని కలపడం ద్వారా కొత్త అద్భుతమైన విషయాలను సృష్టించాలనుకుంటున్నాను.

మీకు ఆసక్తి ఉంటే, దయచేసి రేట్ చేయండి gRPC వెబ్ సర్వర్, నేను పైథాన్ మరియు ఓపెన్‌సివిలో వ్రాసాను. ఇది ముఖం గుర్తించబడిన క్షణంలో డేటాను ప్రసారం చేస్తుంది. విభిన్న ప్రోగ్రామింగ్ భాషలలో విభిన్న క్లయింట్‌లను సృష్టించడానికి ఇది ఆధారం. వారు సర్వర్‌కు కనెక్ట్ చేయగలరు మరియు దాని నుండి డేటాను చదవగలరు.

వ్యాసం చదివినందుకు ధన్యవాదాలు!

Skillbox సిఫార్సు చేస్తోంది:

మూలం: www.habr.com

ఒక వ్యాఖ్యను జోడించండి