OpenCV แแ แแก แแแแแแแแแแ, แ แแแแแแช แจแแฅแแแแแแ แแแแแแฃแขแแ แฃแแ แฎแแแแแก แแ แแแฅแขแแแแกแแแแก. แแก แฃแแแ แแแแฎแแแแแแ 20 แฌแแแกแแ. แแ แแก แแแแแแแงแแแ แแแแแฏแจแ แแ แแฎแแแช แแแงแแแแ แแแก แฉแแแ C++ แแ Python แแ แแแฅแขแแแแกแแแแก, แ แแแแแ แแแก แแฅแแก แแแ แแ แแฎแแ แแแญแแ แ แแ แแแแแแกแแแแก.
แแแแ แแ แ แแแแกแแช แแแแแฌแงแ Go-แก แกแฌแแแแ แแ แแแแแงแแแแแ, แแแแแแขแแ แแกแแ, แจแแแซแแแแแแ แแฃ แแ แ OpenCV-แแก แแแแแงแแแแแ แแ แแแแกแแแ แแฃแจแแแแแกแแแแก. แแ แแ แแก แฃแแแ แแงแ แแแแแแแแแแ แแ แแแแแแแแแแแ แแแขแแแ แแชแแแก แจแแกแแฎแแ, แแแแ แแ แแแฉแแแแแแแแ, แ แแ แแกแแแ แซแแแแแ แ แแฃแแ แแงแ. แชแแขแ แแแแแแแแแแแ แแแแฎแแแ The Hybrid Group-แแก แแแแ แจแแฅแแแแ แจแแคแฃแแแแก. แแ แกแขแแขแแแจแ แแ แแแฉแแแแแแ, แแฃ แ แแแแ แฃแแแ แแแแฌแงแแ GoCV-แแก แแแแแงแแแแแ Haar Cascades-แแ แกแแฎแแก แแแแชแแแแแก แแแ แขแแแ แกแแกแขแแแแก แจแแแฃแจแแแแแแ.
Skillbox แแแ แฉแแแ: แแ แแฅแขแแแฃแแ แแฃแ แกแ
"แแแแแแแก แแแแแแแแแ แ แแฃแแแแแ" .แจแแแแฎแกแแแแแ: "Habr"-แแก แงแแแแ แแแแแฎแแแแแกแแแแก - แคแแกแแแแแแแ 10 แ แฃแแแแแแ Skillbox-แแก แแแแแกแแแแ แแฃแ แกแแ แฉแแ แแชแฎแแแกแแก "Habr" แกแแ แแแแแแ แแแแแก แแแแแงแแแแแแ.
แ แ แแฅแแแแ แกแแญแแ แ:
- แฌแแแ;
- OpenCV (แฅแแแแแ แแแกแขแแแแ แแก แแแฃแแแแ);
- แแแ แแ แฉแแแฃแแแแ แแแ แแแแแแแแแแ แ.
แแแงแแแแแแก
- Linux:
gocv.io/getting-started/linux - macos:
gocv.io/getting-started/macos - Windows:
gocv.io/getting-started/windows
แแแแแแแแ 1
แแแ แแแ แแแแแแแแจแ แจแแแแชแแแแแ แจแแแฅแแแแ แแแแแแแชแแ, แ แแแแแแช แฎแกแแแก แคแแแฏแแ แแก แแแแแ แแก แแแแแ แแแแแแแ.
แแแ แแแ แ แแแจแ, แแฅแแแ แฃแแแ แจแแแแแขแแแแ แแแแแแแแแแแแ, แ แแแแแแแช แแญแแ แแแแแ แกแแแฃแจแแแ.
แแแแแ แขแ (
"แแแแ"
"gocv.io/x/gocv"
)
แแแแก แจแแแแแ, แแฅแแแ แฃแแแ แจแแฅแแแแ VideoCapture แแแแแฅแขแ 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 แขแแแแก Read แแแแแแ. แแแก แแแแแแก Mat แขแแแแก (แแแขแ แแชแ, แ แแแแแแช แฉแแแ แจแแแฅแแแแแ แแแแแ), แแแแแ แฃแแแแก แแแแแแฃแ แแแแจแแแแแแแแก, แ แแแแแแช แแแฃแแแแแแก, แฌแแ แแแขแแแแ แฌแแแแแแฎแ แแฃ แแ แ แฉแแ แฉแ VideoCapture-แแแ.
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
แแ แแแแแแแแจแ, แแแแแแแงแแแแ แฌแแแ แแแแแแแแ แแ แแแแจแแแแ แกแแฎแแก แแแแชแแแแแก แกแแกแขแแแ Haar Cascades-แแก แกแแคแฃแซแแแแแ.
Haar แแแกแแแแแแ แแ แแก แแแกแแแแฃแ แ แแแแกแแคแแแแขแแ แแแ, แ แแแแแแแช แแแแแแแแแฃแแแ Haar wavelet แขแแฅแแแแแก แกแแคแฃแซแแแแแ. แแกแแแ แแแแแแแแแแแ แแแฅแกแแแแแก แแแแแกแแฎแฃแแแแแแ แแแแแ แแขแฃแแ แคแฃแแฅแชแแแแแก แแแกแแซแแแแแ. Haar Cascades-แแก แจแแกแแฎแแ แแแขแแก แแแกแแแแแแ, แแแฎแแแ, แแแฐแงแแแแ แฅแแแแแ แแแชแแแฃแ แแแฃแแแแก.
แฉแแแแขแแแ แแแ แฃแแแ แแแฌแแ แแแแแ แแแกแแแแแแ
แแแแกแแแแแก แแฅแแแ แฃแแแ แจแแฅแแแแ แแแแกแแคแแแแขแแ แ แแ แแแแฌแแแแ แแแก แฃแแแ แแแฌแแ แแแแแ แคแแแแ (แแแฃแแ แแแชแแแฃแแแ แแแแแ). แแ แฃแแแ แแแขแแแ แแ 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-แจแ. แฃแแฎแแแแก แแแแแแแแจแ แแแแแแแ แแ แแฅแกแแแ แแแแแขแแแแก แแแแ แซแแแแแแก แแ แแฎแแแ แแแแแ แ แแแแแแแแก แจแแฅแแแแก Go-แกแ แแ OpenCV-แแก แแแแแแแแชแแแ.
แแแแแขแแ แแกแแแแก แจแแแแฎแแแแแจแ แแแฎแแแ แจแแแคแแกแแ
แแแแแแแแ แกแขแแขแแแก แฌแแแแแฎแแแกแแแแก!
Skillbox แแแ แฉแแแ:
- แแ แฌแแแแแ แแ แแฅแขแแแฃแแ แแฃแ แกแ
"แแ แแแ PRO แแแ แแแแแแแแแ แ" .- แกแแแแแแแแแแแแแแ แแแแแแ แแฃแ แกแ
"แแ แแคแแกแแ Java Developer" .- แแ แแฅแขแแแฃแแ แฌแแแก แแฃแ แกแ
"PHP แแแแแแแแแ แ 0-แแแ PRO-แแแ" .
แฌแงแแ แ: www.habr.com