ಗೋಲಾಂಗ್ ಮತ್ತು ಓಪನ್‌ಸಿವಿ ಆಧಾರಿತ ಮುಖ ಗುರುತಿಸುವಿಕೆ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸುವುದು

OpenCV ಎನ್ನುವುದು ಕಂಪ್ಯೂಟರ್ ದೃಷ್ಟಿ ಯೋಜನೆಗಳಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಗ್ರಂಥಾಲಯವಾಗಿದೆ. ಆಕೆಗೆ ಈಗಾಗಲೇ ಸುಮಾರು 20 ವರ್ಷ. ನಾನು ಅದನ್ನು ಕಾಲೇಜಿನಲ್ಲಿ ಬಳಸಿದ್ದೇನೆ ಮತ್ತು ಈಗಲೂ ನನ್ನ C++ ಮತ್ತು ಪೈಥಾನ್ ಯೋಜನೆಗಳಿಗೆ ಬಳಸುತ್ತಿದ್ದೇನೆ ಏಕೆಂದರೆ ಅದು ಆ ಭಾಷೆಗಳಿಗೆ ಉತ್ತಮ ಬೆಂಬಲವನ್ನು ಹೊಂದಿದೆ.

ಆದರೆ ನಾನು ಗೋವನ್ನು ಕಲಿಯಲು ಮತ್ತು ಬಳಸಲು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಈ ಭಾಷೆಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು OpenCV ಅನ್ನು ಬಳಸಬಹುದೇ ಎಂದು ನಾನು ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇನೆ. ಆ ಸಮಯದಲ್ಲಿ, ಏಕೀಕರಣದ ಕುರಿತು ಈಗಾಗಲೇ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಟ್ಯುಟೋರಿಯಲ್‌ಗಳು ಇದ್ದವು, ಆದರೆ ಅವು ತುಂಬಾ ಸಂಕೀರ್ಣವಾಗಿವೆ ಎಂದು ನನಗೆ ತೋರುತ್ತದೆ. ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ, ಹೈಬ್ರಿಡ್ ಗ್ರೂಪ್ ತಂಡವು ರಚಿಸಿದ ಹೊದಿಕೆಯನ್ನು ನಾನು ನೋಡಿದೆ. ಈ ಲೇಖನದಲ್ಲಿ, ಹಾರ್ ಕ್ಯಾಸ್ಕೇಡ್ಸ್‌ನೊಂದಿಗೆ ಸರಳ ಮುಖ ಗುರುತಿಸುವಿಕೆ ವ್ಯವಸ್ಥೆಯನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಮೂಲಕ GoCV ಯೊಂದಿಗೆ ಹೇಗೆ ಪ್ರಾರಂಭಿಸಬೇಕು ಎಂದು ನಾನು ನಿಮಗೆ ತೋರಿಸುತ್ತೇನೆ.

ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ: ಪ್ರಾಯೋಗಿಕ ಕೋರ್ಸ್ "ಮೊದಲಿನಿಂದ ಪೈಥಾನ್ ಡೆವಲಪರ್".

ನಾವು ನೆನಪಿಸುತ್ತೇವೆ: ಎಲ್ಲಾ Habr ಓದುಗರಿಗೆ - Habr ಪ್ರೊಮೊ ಕೋಡ್ ಬಳಸಿಕೊಂಡು ಯಾವುದೇ ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಕೋರ್ಸ್‌ಗೆ ದಾಖಲಾಗುವಾಗ 10 ರೂಬಲ್ ರಿಯಾಯಿತಿ.

ಏನು ಅಗತ್ಯವಿದೆ:

• ಹೋಗು;
• OpenCV (ಕೆಳಗಿನ ಅನುಸ್ಥಾಪಕ ಲಿಂಕ್‌ಗಳು);
• ವೆಬ್ ಅಥವಾ ಸಾಮಾನ್ಯ ವೀಡಿಯೊ ಕ್ಯಾಮೆರಾ.

ಸೆಟ್ಟಿಂಗ್

• ಲಿನಕ್ಸ್: gocv.io/getting-started/linux
• ಮ್ಯಾಕೋಸ್: gocv.io/getting-started/macos
• ವಿಂಡೋಸ್: gocv.io/getting-started/windows

ಉದಾಹರಣೆಗೆ 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()

ಈಗ ನಾವು ಎನ್-ಡೈಮೆನ್ಷನಲ್ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ. ಇದು ಕ್ಯಾಮರಾದಿಂದ ಓದಿದ ಚಿತ್ರಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.

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

ವೀಡಿಯೊ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸಲು, ನೀವು ವಿಂಡೋವನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ - ಇದನ್ನು NewWindow ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಮಾಡಬಹುದು.

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

ಈಗ ನೀವು ರಚಿಸಿದ ವಿಂಡೋದಲ್ಲಿ ಫ್ರೇಮ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕಾಗಿದೆ. ಮುಂದಿನ ಫ್ರೇಮ್‌ಗೆ ಚಲಿಸುವ ವಿರಾಮವು 50 ms ಆಗಿದೆ.

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

ಚಿತ್ರದಲ್ಲಿ ಮುಖಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು, ನೀವು ವಿಧಾನವನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ ಮಲ್ಟಿಸ್ಕೇಲ್ ಪತ್ತೆ ಮಾಡಿ. ಈ ಕಾರ್ಯವು ಕ್ಯಾಮರಾದ ವೀಡಿಯೋ ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಈಗಷ್ಟೇ ಓದಲಾದ ಚೌಕಟ್ಟನ್ನು (ಟೈಪ್ ಮ್ಯಾಟ್) ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಆಯತದ ಪ್ರಕಾರದ ಶ್ರೇಣಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ರಚನೆಯ ಗಾತ್ರವು ವರ್ಗೀಕರಣವು ಫ್ರೇಮ್‌ನಲ್ಲಿ ಪತ್ತೆಹಚ್ಚಲು ಸಾಧ್ಯವಾಗುವ ಮುಖಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ನಂತರ, ನಾವು ಅದನ್ನು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, ಆಯತಗಳ ಪಟ್ಟಿಯ ಮೂಲಕ ಪುನರಾವರ್ತಿಸೋಣ ಮತ್ತು ಆಯತದ ವಸ್ತುವನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿಸಿ, ಪತ್ತೆಯಾದ ಆಯತದ ಸುತ್ತಲೂ ಗಡಿಯನ್ನು ರಚಿಸೋಣ. ಆಯತ ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಮಾಡಬಹುದು. ಇದು ಕ್ಯಾಮರಾದಿಂದ ಓದಲ್ಪಟ್ಟ ಮ್ಯಾಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಡಿಟೆಕ್ಟ್ಮಲ್ಟಿಸ್ಕೇಲ್ ವಿಧಾನದಿಂದ ಹಿಂತಿರುಗಿಸಲಾದ ಆಯತ ವಸ್ತು, ಗಡಿಯ ಬಣ್ಣ ಮತ್ತು ದಪ್ಪ.

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 ವೆಬ್ ಸರ್ವರ್, ನಾನು ಪೈಥಾನ್ ಮತ್ತು ಓಪನ್‌ಸಿವಿಯಲ್ಲಿ ಬರೆದಿದ್ದೇನೆ. ಮುಖ ಪತ್ತೆಯಾದ ಕ್ಷಣದಲ್ಲಿ ಇದು ಡೇಟಾವನ್ನು ಸ್ಟ್ರೀಮ್ ಮಾಡುತ್ತದೆ. ವಿಭಿನ್ನ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ವಿಭಿನ್ನ ಕ್ಲೈಂಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಇದು ಆಧಾರವಾಗಿದೆ. ಅವರು ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು ಮತ್ತು ಅದರಿಂದ ಡೇಟಾವನ್ನು ಓದಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ಲೇಖನವನ್ನು ಓದಿದ್ದಕ್ಕಾಗಿ ಧನ್ಯವಾದಗಳು!

ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ:

• ಎರಡು ವರ್ಷಗಳ ಪ್ರಾಯೋಗಿಕ ಕೋರ್ಸ್ "ನಾನು PRO ವೆಬ್ ಡೆವಲಪರ್".
• ಶೈಕ್ಷಣಿಕ ಆನ್‌ಲೈನ್ ಕೋರ್ಸ್ "ವೃತ್ತಿ ಜಾವಾ ಡೆವಲಪರ್".
• ಪ್ರಾಯೋಗಿಕ ಒಂದು ವರ್ಷದ ಕೋರ್ಸ್ "0 ರಿಂದ PRO ವರೆಗೆ PHP ಡೆವಲಪರ್".

ಮೂಲ: www.habr.com