OpenCV යනු පරිගණක දර්ශන ව්‍යාපෘති සඳහා නිර්මාණය කර ඇති පුස්තකාලයකි. ඇයට දැනටමත් වයස අවුරුදු 20 ක් පමණ වේ. මම එය විද්‍යාලයේ භාවිතා කළ අතර තවමත් එය මගේ C++ සහ Python ව්‍යාපෘති සඳහා භාවිතා කරන්නේ එම භාෂා සඳහා හොඳ සහයෝගයක් ඇති බැවිනි.
නමුත් මම Go ඉගෙන ගැනීමට සහ භාවිතා කිරීමට පටන් ගත් විට, මෙම භාෂාව සමඟ වැඩ කිරීමට OpenCV භාවිතා කළ හැකිද යන්න ගැන මට උනන්දු විය. එකල, ඒකාබද්ධ කිරීම පිළිබඳ උදාහරණ සහ නිබන්ධන දැනටමත් තිබුණි, නමුත් ඒවා ඉතා සංකීර්ණ බව මට පෙනුනි. ටික වේලාවකට පසු, දෙමුහුන් සමූහයේ කණ්ඩායම විසින් නිර්මාණය කරන ලද දවටනයක් මට හමු විය. මෙම ලිපියෙන්, Haar Cascades සමඟ සරල මුහුණු හඳුනාගැනීමේ පද්ධතියක් සංවර්ධනය කිරීමෙන් GoCV සමඟ ආරම්භ කරන්නේ කෙසේදැයි මම ඔබට පෙන්වන්නම්.
Skillbox නිර්දේශ කරයි: ප්රායෝගික පාඨමාලාව .
අපි ඔබට මතක් කරමු: "Habr" හි සියලුම පාඨකයින් සඳහා - "Habr" ප්‍රවර්ධන කේතය භාවිතයෙන් ඕනෑම Skillbox පාඨමාලාවකට ලියාපදිංචි වන විට රූබල් 10 ක වට්ටමක්.
අවශ්ය දේ:
- යන්න;
- OpenCV (ස්ථාපක සබැඳි පහතින්);
- වෙබ් හෝ සාමාන්‍ය වීඩියෝ කැමරාව.
ස්ථාපනය
- ලිනක්ස්:
- මැකෝස්:
- වින්ඩෝස්:
උදාහරණයක් 1
පළමු උදාහරණයේදී, අපි කැමරා වීඩියෝ ප්රවාහයක් පෙන්වන කවුළුවක් විවෘත කරන යෙදුමක් නිර්මාණය කිරීමට උත්සාහ කරමු.
මුලින්ම ඔබ වැඩ සඳහා අවශ්ය පුස්තකාල ආනයනය කළ යුතුය.
ආනයන (
"ලඝු"
"gocv.io/x/gocv"
)
මෙයින් පසු, ඔබට VideoCaptureDevice ශ්රිතය භාවිතයෙන් VideoCapture වස්තුවක් සෑදිය යුතුය. දෙවැන්න කැමරාවක් භාවිතයෙන් වීඩියෝ ප්රවාහයක් ග්‍රහණය කර ගැනීමට හැකි වේ. ශ්රිතය පරාමිතියක් ලෙස පූර්ණ සංඛ්‍යාවක් භාවිතා කරයි (එය උපාංග හැඳුනුම්පත නියෝජනය කරයි).
webcam, err := gocv.VideoCaptureDevice(0)
if err != nil { log.Fatalf(“error opening web cam: %v”, err)
}
defer webcam.Close()දැන් අපි n-dimensional matrix එකක් සාදාගත යුතුයි. එය කැමරාවෙන් කියවන පින්තූර ගබඩා කරනු ඇත.
img := gocv.NewMat()
defer img.Close()වීඩියෝ ප්රවාහයක් ප්රදර්ශනය කිරීම සඳහා, ඔබ කවුළුවක් සෑදිය යුතුය - මෙය NewWindow ශ්රිතය භාවිතයෙන් කළ හැකිය.
window := gocv.NewWindow(“webcamwindow”)
defer window.Close()දැන් අපි වඩාත් රසවත් කොටස වෙත යමු.
වීඩියෝ යනු රූප රාමු වල අඛණ්ඩ ප්රවාහයක් වන බැවින්, කැමරාවේ වීඩියෝ ප්‍රවාහය නිමක් නැතිව කියවීමට අපට අනන්ත ලූපයක් නිර්මාණය කිරීමට අවශ්ය වනු ඇත. මෙය සිදු කිරීම සඳහා, ඔබට VideoCapture වර්ගයේ කියවීමේ ක්රමය අවශ්ය වේ. එය VideoCapture වෙතින් රාමුව සාර්ථකව කියවා තිබේද නැද්ද යන්න දැක්වෙන බූලියන් අගයක් ලබා දෙමින් Mat වර්ගයක් (අප ඉහත නිර්මාණය කළ න්‍යාසය) අපේක්ෂා කරනු ඇත.
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 Cascades ගැන වැඩි විස්තර දැන ගැනීමට කරුණාකර පහත සබැඳි අනුගමනය කරන්න.
දැනටමත් පුහුණු කර ඇති කැස්කැඩ් බාගන්න . වත්මන් උදාහරණයේ දී, ඉදිරියෙන් පුද්ගලයෙකුගේ මුහුණ හඳුනා ගැනීමට කඳුරැල්ල භාවිතා කරනු ඇත.
මෙය සිදු කිරීම සඳහා, ඔබ වර්ගීකරණයක් සාදා එය දැනටමත් පුහුණු කර ඇති ගොනුවක් පෝෂණය කළ යුතුය (සබැඳිය ඉහත දක්වා ඇත). මම දැනටමත් 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 ඒකාබද්ධ කිරීමෙන් නව සිසිල් දේවල් නිර්මාණය කිරීමට අදහස් කරමි.
ඔබ උනන්දුවක් දක්වන්නේ නම්, කරුණාකර ශ්‍රේණිගත කරන්න , මම Python සහ OpenCV හි ලියා ඇත. එය මුහුණක් අනාවරණය කරගත් මොහොතේම දත්ත ප්‍රවාහ කරයි. විවිධ ක්‍රමලේඛන භාෂාවලින් විවිධ සේවාලාභීන් නිර්මාණය කිරීමේ පදනම මෙයයි. ඔවුන්ට සේවාදායකයට සම්බන්ධ වීමට සහ එයින් දත්ත කියවීමට හැකි වනු ඇත.
ලිපිය කියවීම ගැන ඔබට ස්තුතියි!
Skillbox නිර්දේශ කරයි:
- වසර දෙකක ප්රායෝගික පාඨමාලාව .
- අධ්‍යාපනික මාර්ගගත පාඨමාලාව .
- ප්රායෝගික වසර පාඨමාලාව .
මූලාශ්රය: www.habr.com