ગોલાંગ અને ઓપનસીવી પર આધારિત ફેસ રેકગ્નિશન સિસ્ટમ બનાવવી

OpenCV એ કમ્પ્યુટર વિઝન પ્રોજેક્ટ્સ માટે રચાયેલ લાઇબ્રેરી છે. તેણી પહેલેથી જ લગભગ 20 વર્ષની છે. મેં તેનો કોલેજમાં ઉપયોગ કર્યો હતો અને હજુ પણ મારા C++ અને Python પ્રોજેક્ટ્સ માટે તેનો ઉપયોગ કરું છું કારણ કે તેમાં તે ભાષાઓ માટે સારો સપોર્ટ છે.

પરંતુ જ્યારે મેં Go શીખવાનું અને તેનો ઉપયોગ કરવાનું શરૂ કર્યું, ત્યારે મને આ ભાષા સાથે કામ કરવા માટે OpenCV નો ઉપયોગ કરી શકાય કે કેમ તેમાં રસ પડ્યો. તે સમયે, એકીકરણ પર પહેલાથી જ ઉદાહરણો અને ટ્યુટોરિયલ્સ હતા, પરંતુ તે મને લાગતું હતું કે તે ખૂબ જટિલ હતા. થોડી વાર પછી, હું ધ હાઇબ્રિડ ગ્રુપ ટીમ દ્વારા બનાવેલ રેપર સામે આવ્યો. આ લેખમાં, હું તમને બતાવીશ કે Haar Cascades સાથે એક સરળ ચહેરો ઓળખવાની સિસ્ટમ વિકસાવીને GoCV સાથે કેવી રીતે શરૂઆત કરવી.

સ્કિલબોક્સ ભલામણ કરે છે: પ્રેક્ટિકલ કોર્સ "શરૂઆતથી પાયથોન ડેવલપર".

અમે યાદ કરાવીએ છીએ: Habrના તમામ વાચકો માટે - Habr પ્રોમો કોડનો ઉપયોગ કરીને કોઈપણ સ્કિલબોક્સ કોર્સમાં નોંધણી કરતી વખતે 10 રૂબલ ડિસ્કાઉન્ટ.

શું જરૂરી છે:

• જાઓ;
• OpenCV (નીચે ઇન્સ્ટોલર લિંક્સ);
• વેબ અથવા નિયમિત વિડિયો કેમેરા.

સ્થાપન

• Linux: gocv.io/getting-started/linux
• macOS: gocv.io/getting-started/macos
• Windows: gocv.io/getting-started/windows

ઉદાહરણ 1

પ્રથમ ઉદાહરણમાં, અમે એક એપ્લિકેશન બનાવવાનો પ્રયાસ કરીશું જે કેમેરા વિડિઓ સ્ટ્રીમ દર્શાવતી વિંડો ખોલે છે.

પ્રથમ તમારે કામ માટે જરૂરી પુસ્તકાલયો આયાત કરવાની જરૂર છે.

આયાત (
"લોગ"
"gocv.io/x/gocv"
)

આ પછી, તમારે VideoCaptureDevice ફંક્શનનો ઉપયોગ કરીને VideoCapture ઑબ્જેક્ટ બનાવવાની જરૂર છે. બાદમાં કેમેરાનો ઉપયોગ કરીને વિડિઓ સ્ટ્રીમ કેપ્ચર કરવાનું શક્ય બનાવે છે. ફંક્શન પરિમાણ તરીકે પૂર્ણાંકનો ઉપયોગ કરે છે (તે ઉપકરણ 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()

વિડિઓ સ્ટ્રીમ પ્રદર્શિત કરવા માટે, તમારે વિન્ડો બનાવવાની જરૂર છે - આ ન્યૂવિન્ડો ફંક્શનનો ઉપયોગ કરીને કરી શકાય છે.

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)
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 પર આધારિત ફેસ રેકગ્નિશન સિસ્ટમ બનાવીએ.

હાર કાસ્કેડ એ કાસ્કેડ વર્ગીકૃત છે જેને હાર વેવલેટ તકનીકનો ઉપયોગ કરીને તાલીમ આપવામાં આવે છે. તેઓ અમુક વિશેષતાઓને શોધવા માટે ઇમેજમાં પિક્સેલનું વિશ્લેષણ કરે છે. હાર કાસ્કેડ્સ વિશે વધુ જાણવા માટે, કૃપા કરીને નીચેની લિંક્સને અનુસરો.

વાયોલા-જોન્સ ઑબ્જેક્ટ ડિટેક્શન ફ્રેમવર્ક
કેસ્કેડીંગ વર્ગીકૃત
હાર જેવું લક્ષણ

પહેલેથી જ પ્રશિક્ષિત કાસ્કેડ ડાઉનલોડ કરો અહીં હોઈ શકે છે. વર્તમાન ઉદાહરણમાં, આગળથી વ્યક્તિના ચહેરાને ઓળખવા માટે કાસ્કેડનો ઉપયોગ કરવામાં આવશે.

આ કરવા માટે, તમારે ક્લાસિફાયર બનાવવાની જરૂર છે અને તેને પહેલેથી જ પ્રશિક્ષિત ફાઇલ ફીડ કરવાની જરૂર છે (લિંક ઉપર આપેલી છે). મેં પહેલેથી જ 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 વેબ સર્વર, જે મેં Python અને OpenCV માં લખ્યું છે. જ્યારે ચહેરો શોધાય છે ત્યારે તે ડેટાને સ્ટ્રીમ કરે છે. આ વિવિધ પ્રોગ્રામિંગ ભાષાઓમાં વિવિધ ક્લાયંટ બનાવવા માટેનો આધાર છે. તેઓ સર્વર સાથે કનેક્ટ થઈ શકશે અને તેમાંથી ડેટા વાંચી શકશે.

લેખ વાંચવા બદલ આભાર!

સ્કિલબોક્સ ભલામણ કરે છે:

• બે વર્ષનો પ્રેક્ટિકલ કોર્સ "હું પ્રો વેબ ડેવલપર છું".
• શૈક્ષણિક ઓનલાઈન કોર્સ "પ્રોફેશન જાવા ડેવલપર".
• એક વર્ષનો પ્રેક્ટિકલ કોર્સ "0 થી PRO સુધી PHP વિકાસકર્તા".

સોર્સ: www.habr.com