Ansikts- og bevegelsesdeteksjon ved hjelp av datasyn

OpenCV (Open Source Computer Vision Library) er en Python -modul som brukes til datamaskinvisjon. Det er en enorm modul med eksepsjonelle evner. Vi kan gjøre mange ting med datasyn, og noen av de største er ansiktsgjenkjenning og bevegelsesdeteksjon.

I denne opplæringen vil du lære å skrive kode for å oppdage ansikter i bilder, videoer og bevegelse.

For å unngå alle slags feil og problemer, vil vi laste ned OpenCV -filen fra GitHub på https: // github.com/opencv/opencv. Vi bruker noen av filene i for å fullføre koden.

Ansiktsdeteksjon ved hjelp av bilder

Innenfor GitHub OpenCV-filen er det en underkatalog (OpenCV-Master \ prøver \ data) kalt data der eksempler på bilder og videoer å jobbe med er tilgjengelige. Vi bruker bilder og videoer som finnes i denne katalogen. Spesielt vil jeg bruke Lena.JPG -fil. Jeg vil kopiere og lime den inn i Pycharm Working Directory (i mitt tilfelle er det C: \ Brukere \ Never \ PycharmProjects \ PythonProject). La oss nå starte ansiktsdeteksjon på dette bildet.

La oss først laste opp modulene vi trenger:

Importer numpy som NP
Importer CV2

Filen vi skal bruke er lokalisert på OpenCV-Master \ Data \ Haarcascades \ haarcascade_frontalface_default.XML av filen lastet ned fra github. Vi må legge en lenke til Haarcascade -filen som følger:

face_cascade = cv2.Cascadeclassifier ('c: \\ brukere \\ aldri \\ nedlastinger \\ opencv-master \\ data \\ haarcascades \\ haarcascade_frontalface_default.xml ')

Last bildet for å utføre ansiktsdeteksjonen ved hjelp av CV2.IMREAD () Metode.

Bilde = CV2.imread ('lena.jpg ')

Vårt neste mål er å gjøre bildet til gråtoner. Sistnevnte er ferdig med CV2.cvtColor () -metode. Denne metoden tar to argumenter. Det første argumentet er navnet på filen som skal konverteres, og det andre argumentet er konverteringsformatet. I dette tilfellet vil vi bruke CV2.Color_bgr2gray for å konvertere det til et gråtonformat.

grå = cv2.cvtColor (bilde, cv2.Color_bgr2gray)

Vi bruker deretter detectMultiscale () -funksjonen for å oppdage objekter eller i dette tilfellet ansikter. Her vil vi fortelle Python face_cascade.detectMultiscale (), som vil oppdage ansikter siden det er det i Face_cascade -parameteren. Funksjonen detektmultiscale () tar noen få argumenter, bildet, en skaleringsfaktor, minimum antall naboer, flagg, minimumsstørrelse og maksimal størrelse.

Faces = face_cascade.DetectMultiscale (grå, 1.5, 5)

For å plassere en rektangulær boks rundt ansiktet, må vi bruke CV2.Rektangel () -metode. Ved å bruke denne metoden, må vi gi den noen få argumenter. Det første argumentet er bildet du vil ha dette på, det andre argumentet er startpunktet for rektangelet, det tredje argumentet er sluttpunktet for rektangelet, det fjerde argumentet er fargen på rektangelet, og det femte argumentet er tykkelsen på køen. I dette tilfellet er w for bredde, h er for høyde, og x og y er utgangspunktet.

for (x, y, w, h) i ansikter:
CV2.Rektangel (bilde, (x, y), (x+w, y+h), (0,255,0), 3)

Til slutt viser vi bildet ved hjelp av CV2.IMshow () -metode. Vi bruker også CV2.WaitKey (0) for å sette en uendelig ventetid og bruke CV2.DestroyAllWindows () Metode for å lukke vinduet.

CV2.Imshow ('image', image)
CV2.WaitKey (0)
CV2.DestroyAllWindows ()

Ansiktsdeteksjon ved hjelp av videoer/webkamera

I dette tilfellet kommer vi til å oppdage ansikter i sanntid ved å bruke et webkamera eller en video. Nok en gang begynner vi med å importere de nødvendige modulene.

Importer numpy som NP
Importer CV2

Deretter må vi spesifisere plasseringen av Haarcascade -filene. Vi gjør dette som følger (akkurat som for bildet):

face_cascade = cv2.Cascadeclassifier ('c: \\ brukere \\ aldri \\ nedlastinger \\ opencv-master \\ data \\ haarcascades \\ haarcascade_frontalface_default.xml ')

Nå må vi spesifisere videoen vi ønsker å håndtere ved hjelp av CV2.Videocapture () Metode. I mitt tilfelle har jeg valgt å takle en video jeg hadde og skrevet inn navnet på videoen. Hvis du vil håndtere webkameraer, vil du legge en 0 i stedet for navnet på videofilen.

Video = CV2.Videocapture ("Video.mp4 ")

Vi begynner deretter en stundsløyfe. I mens vi er sant, ber vi programmet om å oppdage ansiktene til vi stopper det. I første omgang leste vi videofilen ved hjelp av lese () -funksjonen.

Mens sant:
ret, image = video.lese()

Akkurat som i forrige seksjon, må vi gjøre bildene eller rammene til gråtoner for enkel deteksjon. Vi bruker CV2.cvtColor () -metode for å endre rammene til grå.

grå = cv2.cvtColor (bilde, cv2.Color_bgr2gray)

For å oppdage ansiktene bruker vi funksjonen detektmultiscale (). Nok en gang tar det de samme parametrene som i forrige avsnitt.

Faces = face_cascade.DetectMultiscale (grå, 1.1, 4)

For å plassere rektangler rundt ansiktene, bruker vi CV2.Rektangel () -metode. Dette ligner på forrige seksjon.

for (x, y, w, h) i ansikter:
CV2.Rektangel (bilde, (x, y), (x+w, y+h), (255, 0, 0), 2)

Vi viser deretter rammene ved hjelp av CV2.IMshow () -metode. Denne metoden tar to argumenter, den første er navnet på rammen, og den andre er rammen som skal vises.

CV2.Imshow ('image', image)

Vi setter en klausul, hvis brukeren trykker på ESC -tasten (eller 27), vil koden bryte ut av løkken.

Hvis CV2.WaitKey (0) & 0xff == 27:
gå i stykker

Til slutt gir vi ut videoen ved hjelp av utgivelsesfunksjonen ().

video.utgivelse()

Bevegelsessensor

Bevegelsesdeteksjon er flott! Hva det betyr er at med Python og et godt webkamera kan vi lage vårt eget sikkerhetskamera! Så la oss begynne.

Importer numpy som NP
Importer CV2

Jeg plukker en video fra prøvene (OpenCV-Master \ prøver \ data) av github-filen.

Video = CV2.Videocapture ("Vtest.avi ")

For å oppdage bevegelse, er det vi i utgangspunktet stoler på forskjellen i pikselverdiene til to bilder, et referansebilde og et annet bilde eller ramme. Så vi lager to bilder, Frame1 og Frame2.

ret, ramme1 = video.lese()
ret, ramme2 = video.lese()

Mens videoen åpnes eller bruker ISOPened () -funksjonen, begynner vi en loop.

Mens video.isopened ():

Vi beregner først den absolutte forskjellen mellom Frame1 og Frame2 ved bruk av CV2.AbsDiff () -metode. Det er klart det tar to argumenter, de første og andre rammene.

Forskjell = CV2.AbsDiff (Frame1, Frame2)

Ettersom ting er lettere i svart og hvitt, vil vi gjøre forskjellen til gråtoner ved hjelp av CV2.cvtColor () -metode. CV2.CVTColor () -metode tar to argumenter, den første er rammen eller bildet, og den andre er transformasjonen. I dette tilfellet vil vi bruke CV2.Color_bgr2gray.

grå = cv2.cvtColor (forskjell, cv2.Color_bgr2gray)

Når bildet er i gråtoner, må vi deretter uskarpe bildet for å fjerne støy ved hjelp av CV2.GaussianBlur () -metode. CV2.GaussianBlur () -metoden tar noen få argumenter-kildebildet for å uskarpe, utgangsbildet, Gaussisk kjernestørrelse, kjernestandardavvik langs x-aksen, kjernestandardavviket langs y-aksen og grensetypen.

uskarphet = cv2.Gaussianblur (grå, (5,5), 0)

Deretter plasserer vi en terskelverdi ved hjelp av CV2.Terskel () -metode. Denne teknikken vil isolere bevegelsen ved å segmentere bakgrunnen og forgrunnen (eller bevegelsen). CV2.Terskel () -metoden tar fire argumenter: bildet, terskelverdien, maksimalverdien å bruke med terskel_binær og terskel_binær_inv, og terskeltypen.

_, terskel = cv2.Terskel (Blur, 20, 255, CV2.TRESH_BINARY)

Deretter utvider vi oss med CV2.Dilate () Metode som tar 6 argumenter maksimalt: bildet, kjernen, ankeret, iterasjonene, grensetypen og grenseverdien.

dilate = cv2.Dilate (terskel, ingen, iterasjoner = 3)

CV2.FindContours () -metoden gjør akkurat det den betyr, den finner konturer. Det tar tre argumenter: kildebildet, gjenvinningsmodus og kontur tilnærmingsmetode.

kontur, _ = cv2.findContours (dilate, cv2.Ret_tree, v2.Chain_approx_simple)

CV2.DrawContours () -metode brukes til å tegne konturene. Det tar noen få argumenter: bildet, konturene, konturidxen (denne verdien er negativ hvis alle konturer er tegnet), farge, tykkelse, linjetype, hierarki, maks nivå og forskyvning.

CV2.DrawContours (Frame1, Contour, -1, (0, 0, 255), 2)

Endelig viser vi bildet ved hjelp av CV2.IMshow () -metode.

CV2.Imshow ("Image", Frame1)

Nå setter vi den første rammen 2 som den første rammen, og leste videoen for en ny ramme som vi plasserer i Frame2 -parameteren.

ramme1 = ramme2
ret, ramme2 = video.lese()

Hvis "Q" -tasten trykkes, bryt ut av løkken:

Hvis CV2.WaitKey (40) == Ord ('Q'):
gå i stykker
video.utgivelse()

Koden som helhet for bevegelsesdeteksjon vil se ut som dette:

Importer numpy som NP
Importer CV2
Video = CV2.Videocapture ("Vtest.avi ")
ret, ramme1 = video.lese()
ret, ramme2 = video.lese()
Mens video.isopened ():
Forskjell = CV2.AbsDiff (Frame1, Frame2)
grå = cv2.cvtColor (forskjell, cv2.Color_bgr2gray)
uskarphet = cv2.Gaussianblur (grå, (5,5), 0)
_, terskel = cv2.Terskel (Blur, 20, 255, CV2.TRESH_BINARY)
dilate = cv2.Dilate (terskel, ingen, iterasjoner = 3)
kontur, _ = cv2.findContours (dilate, cv2.Ret_tree, CV2.Chain_approx_simple)
CV2.DrawContours (Frame1, Contour, -1, (0, 0, 255), 2)
CV2.Imshow ("Image", Frame1)
ramme1 = ramme2
ret, ramme2 = video.lese()
Hvis CV2.WaitKey (40) == Ord ('Q'):
gå i stykker
video.utgivelse()

Det er bare så enkelt! Noen få kodelinjer, og vi kan lage våre egne ansiktsgjenkjennings- og bevegelsesdeteksjonsprogrammer. Noen flere linjer, og vi kan til og med få dem til å snakke (si ved hjelp av PTTSX3) og lage våre egne sikkerhetskameraer!

Glad koding!