கோலாங் மற்றும் ஓபன்சிவி அடிப்படையில் முகம் அடையாளம் காணும் அமைப்பை உருவாக்குதல்

OpenCV என்பது கணினி பார்வை திட்டங்களுக்காக உருவாக்கப்பட்ட ஒரு நூலகம் ஆகும். அவளுக்கு ஏற்கனவே 20 வயது இருக்கும். நான் அதை கல்லூரியில் பயன்படுத்தினேன், இன்னும் எனது C++ மற்றும் Python திட்டங்களுக்கு பயன்படுத்துகிறேன், ஏனெனில் இது அந்த மொழிகளுக்கு நல்ல ஆதரவைக் கொண்டுள்ளது.

ஆனால் நான் Go கற்கவும் பயன்படுத்தவும் தொடங்கியபோது, ​​​​இந்த மொழியுடன் வேலை செய்ய OpenCV பயன்படுத்த முடியுமா என்று நான் யோசித்தேன். அந்த நேரத்தில் ஒருங்கிணைப்பு பற்றிய எடுத்துக்காட்டுகள் மற்றும் பயிற்சிகள் ஏற்கனவே இருந்தன, ஆனால் அவை மிகவும் சிக்கலானவை என்று எனக்குத் தோன்றியது. சிறிது நேரம் கழித்து, ஹைப்ரிட் குழுமத்தால் உருவாக்கப்பட்ட ரேப்பரை நான் கண்டேன். இந்த கட்டுரையில், ஹார் கேஸ்கேட்ஸ் மூலம் எளிய முகத்தை அடையாளம் காணும் அமைப்பை உருவாக்குவதன் மூலம் GoCVஐ எவ்வாறு தொடங்குவது என்பதை நான் உங்களுக்குக் காண்பிப்பேன்.

Skillbox பரிந்துரைக்கிறது: நடைமுறை படிப்பு "புதிதாக பைதான் டெவலப்பர்".

நாங்கள் நினைவூட்டுகிறோம்: "Habr" இன் அனைத்து வாசகர்களுக்கும் - "Habr" விளம்பரக் குறியீட்டைப் பயன்படுத்தி எந்த Skillbox படிப்பிலும் சேரும்போது 10 ரூபிள் தள்ளுபடி.

என்ன தேவைப்படுகிறது:

• போ;
• OpenCV (கீழே உள்ள நிறுவிக்கான இணைப்புகள்);
• வலை அல்லது வழக்கமான கேம்கோடர்.

நிறுவல்

• லினக்ஸ்: gocv.io/getting-started/linux
• MacOS: gocv.io/getting-started/macos
• விண்டோஸ்: gocv.io/getting-started/windows

உதாரணமாக 1

முதல் எடுத்துக்காட்டில், கேமரா வீடியோ ஸ்ட்ரீம் மூலம் சாளரத்தைத் திறக்கும் பயன்பாட்டை உருவாக்க முயற்சிப்போம்.

முதலில் நீங்கள் வேலை செய்ய வேண்டிய நூலகங்களை இறக்குமதி செய்ய வேண்டும்.

இறக்குமதி (
"பதிவு"
"gocv.io/x/gocv"
)

அதன் பிறகு, நீங்கள் VideoCaptureDevice செயல்பாட்டைப் பயன்படுத்தி வீடியோ கேப்சர் பொருளை உருவாக்க வேண்டும். பிந்தையது கேமராவைப் பயன்படுத்தி வீடியோ ஸ்ட்ரீமைப் பிடிக்க உதவுகிறது. செயல்பாடு ஒரு முழு எண்ணை அளவுருவாக எடுத்துக்கொள்கிறது (இது சாதன ஐடியைக் குறிக்கிறது).

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 எம்.எஸ்.

window.IMShow(img)
window.WaitKey(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 இல் எழுதப்பட்ட எளிய முகத்தை அடையாளம் காணும் அமைப்பு உள்ளது. எதிர்காலத்தில், இந்த சோதனைகளைத் தொடரவும், Go மற்றும் OpenCVஐ இணைப்பதன் மூலம் புதிய விஷயங்களை உருவாக்கவும் திட்டமிட்டுள்ளேன்.

நீங்கள் ஆர்வமாக இருந்தால், மதிப்பிடவும் gRPC இணைய சேவையகம், நான் பைதான் மற்றும் ஓபன்சிவியில் எழுதியது. முகம் கண்டறியப்பட்டவுடன் தரவை ஸ்ட்ரீம் செய்கிறது. வெவ்வேறு நிரலாக்க மொழிகளில் வெவ்வேறு வாடிக்கையாளர்களை உருவாக்குவதற்கான அடிப்படை இதுவாகும். அவர்கள் சேவையகத்துடன் இணைக்கவும் அதிலிருந்து தரவைப் படிக்கவும் முடியும்.

கட்டுரையைப் படித்ததற்கு நன்றி!

Skillbox பரிந்துரைக்கிறது:

• இரண்டு வருட நடைமுறை படிப்பு "நான் ஒரு புரோ வெப் டெவலப்பர்".
• கல்வி ஆன்லைன் படிப்பு "தொழில் ஜாவா டெவலப்பர்".
• நடைமுறை ஆண்டு படிப்பு "0 முதல் PRO வரையிலான PHP டெவலப்பர்".

ஆதாரம்: www.habr.com