- Detectarea obiectelor folosind SIFT
- Detectarea obiectelor folosind ORB
- Histograma gradienților orientați (HOG)
- Histograma gradienților orientați (HOG), pas cu pas:
- Clasificatori în cascadă HAAR
- Detectarea feței și a ochilor
- Detectarea Live Face și Eye
- Reglarea clasificatoarelor în cascadă
- Detectarea autoturismelor și pietonilor în videoclipuri
Am început cu instalarea python OpenCV pe Windows și până acum am făcut câteva prelucrări de bază, segmentare a imaginilor și detectarea obiectelor folosind Python, care sunt acoperite în tutorialele de mai jos:
- Noțiuni introductive despre Python OpenCV: instalare și procesare de bază a imaginilor
- Manipulări de imagine în Python OpenCV (Partea 1)
- Manipulări de imagine în OpenCV (Partea 2)
- Segmentarea imaginii folosind OpenCV - Extragerea zonelor specifice unei imagini
De asemenea, am aflat despre diferite metode și algoritmi pentru detectarea obiectelor în care au fost identificate câteva puncte cheie pentru fiecare obiect folosind algoritmi diferiți. În acest tutorial vom folosi acei algoritmi pentru a detecta obiecte din viața reală, aici vom folosi SIFT și ORB pentru detectare.
Detectarea obiectelor folosind SIFT
Aici detectarea obiectelor se va face folosind fluxul live de webcam, deci dacă recunoaște obiectul, acesta menționează obiectul găsit. În cod, partea principală este jucată de funcția numită detector SIFT, cea mai mare parte a procesării fiind realizată de această funcție.
Și în cealaltă jumătate a codului, începem cu deschiderea fluxului webcam, apoi încărcăm șablonul de imagine, adică imaginea de referință, adică programul se uită de fapt prin fluxul webcam.
În continuare, capturăm în mod continuu imaginile din fluxul camerei web cu ajutorul buclei infinite while , apoi capturăm înălțimea și lățimea corespunzătoare a cadrului camerei web, iar apoi definim parametrii casetei regiunii de interes (ROI) în care obiectul nostru se poate potrivi luând înălțimea și lățimea corespunzătoare a cadrului camerei web. Și apoi desenăm dreptunghiul din parametrii ROI pe care i-am definit mai sus. Apoi decupați dreptunghiul și introduceți-l în partea detectorului SWIFT a codului.
Acum, detectorul SIFT are practic două intrări, una este imaginea decupată și cealaltă este șablonul de imagine pe care l-am definit anterior și apoi ne oferă câteva potriviri, deci potrivirile sunt practic numărul de obiecte sau puncte cheie care sunt similare în imaginea decupată și imaginea țintă. Apoi definim o valoare prag pentru potriviri, dacă valoarea potrivirilor este mai mare decât pragul, vom pune imaginea găsită pe ecranul nostru cu culoarea verde a dreptunghiului ROI.
Acum să ne întoarcem la partea principală a codului, funcția care este numită detector SIFT, ia intrarea ca două imagini, una este imaginea în care caută obiectul, iar alta este obiectul pe care încercăm să îl potrivim către (șablon imagine). Apoi, scalați gri prima imagine și definiți șablonul de imagine ca a doua imagine. Apoi creăm un obiect detector SIFT și rulăm funcția OpenCV SIFT de detectare și calculare, astfel încât să detectăm punctele cheie și să calculăm descriptorii, descriptorii sunt practic vectorii care stochează informațiile despre punctele cheie și este foarte important pe măsură ce facem potrivirea între descriptorii imaginilor.
Și apoi definiți potrivitorul bazat pe FLANN, nu intrăm în teoria matematică a potrivirii din spatele acestuia, dar puteți cu ușurință Google despre asta. În primul rând, definiți indexul kdtree la zero și apoi stabilim parametrii indexului și căutării în format dicționar, definim doar algoritmul pe care urmează să-l folosim, care este KDTREE, și numărul de copaci pe care îl vom folosi, cu atât mai mult copac folosim cu atât devine mai complicat și mai lent. Și în parametrul de căutare definiți numărul de verificări, care este practic numărul de potriviri pe care le va finaliza.
Și apoi creați obiectul nostru de potrivire bazat pe FLANN încărcând parametrul pe care l-am definit anterior, care sunt parametrii indexului și parametrii de căutare și pe baza acestuia creați potrivitorul nostru bazat pe FLANN, care este un potrivitor KNN în care KNN este cel mai apropiat vecin K, practic este un mod în care căutăm potrivitorii și descriptorii cei mai apropiați și facem potrivirea cu constanta de inițializare k. Acum acest meci din FLANN returnează numărul de meciuri pe care le primim.
Potrivirea bazată pe FLANN este doar o aproximare, astfel încât pentru a crește acuratețea potrivitorului bazat pe FLANN, efectuăm un test al raportului Lowe și ceea ce face este să caute potrivirile din potrivitorul bazat pe flann knn și să definim câțiva parametri matrici, care este distanța aici, pentru care distanța este o funcție numpy și, odată ce îndeplinește criteriile, adăugați potrivirile la potrivirile bune și returnează potrivirile bune găsite, astfel fluxul video live indică numărul de potriviri găsite în colțul ecranului.
Acum să analizăm codul pentru descrierea de mai sus:
import cv2 import numpy as np def sift_detector (new_image, image_template): # Funcție care compară imaginea de intrare cu șablonul # Se returnează apoi numărul de potriviri SIFT dintre ele image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) image2 = image_template # Create Obiect detector SIFT #sift = cv2.SIFT () sift = cv2.xfeatures2d.SIFT_create () # Obțineți punctele cheie și descriptorii folosind puncte cheie SIFT_1, descriptori_1 = sift.detectAndCompute (image1, None) keypoints_2, descriptors_2 = sift.det Niciunul) # Definiți parametrii pentru Flann Matcher FLANN_INDEX_KDTREE = 0 index_params = dict (algoritm = FLANN_INDEX_KDTREE, copaci = 3) search_params = dict (controale = 100) # Crearea obiectului Flann Matcher Flann = cv2.FlannBasedMatcher (index_params, search_params) # Obține meciuri folosind K-Cel mai apropiat Neighbor Metoda # rezultatul 'matchs' este numărul de meciuri similare gasite in ambele imagini meciuri = flann.knnMatch (descriptori_1, descriptori_2, k = 2) # Stocați potrivirile bune utilizând testul raportului Lowe good_matches = pentru m, n în meciuri: dacă distanța m <0,7 * n. distanța : good_matches.append (m) return len (good_matches) cap = cv2.VideoCapture (0) # Încărcați șablonul nostru de imagine, aceasta este imaginea noastră de referință image_template = cv2.imread ('phone.jpg', 0) în timp ce este adevărat: # Obțineți imagini cu webcam ret, frame = cap.read () # Obțineți înălțimea și lățimea camerei web înălțimea cadrului , lățimea = frame.shape # Definiți dimensiunile casetei ROI top_left_x = int (width / 3) top_left_y = int ((height / 2) + (height / 4)) bottom_right_x = int ((width / 3) * 2) bottom_right_y = int ((height / 2) - (height / 4)) # Desenați fereastra dreptunghiulară pentru regiunea noastră de interes cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) # Decupați fereastra de observație definită mai sus decupată = cadru # Întoarceți orientarea cadrului orizontal cadru = cv2.flip (cadru, 1) # Obțineți numărul de potriviri SIFT potriviri = sift_detector (decupat, model_imagine) # Afișați șirul de stare care afișează nr. de potriviri cv2.putText (cadru, str (potriviri), (450,450), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 1) # Pragul nostru pentru a indica detecția obiectului # Folosim 10 deoarece detectorul SIFT returnează puține pozitii false prag = 10 # Dacă potrivirile depășesc pragul nostru, atunci obiectul a fost detectat dacă se potrivește> prag: cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (frame, „Obiect găsit”, (50,50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow („Detector de obiecte folosind SIFT”, cadru) dacă cv2.waitKey (1) == 13: # 13 este Enter Key break cap.release () cv2.destroyAllWindows ()
Detectarea obiectelor folosind ORB
Detectarea obiectelor folosind SIFT este destul de interesantă și precisă, deoarece generează un număr mult mai precis de potriviri bazate pe puncte cheie, totuși este patentat și asta face dificilă utilizarea acestuia pentru aplicațiile comerciale, cealaltă cale de ieșire este algoritmul ORB pentru detectarea obiectelor.
Similar cu metoda de detectare a obiectelor de către SIFT în care am împărțit programul în două părți, același lucru va fi urmat aici.
În primul rând, definim funcția ORB_detector care ia două intrări, una este imaginea de flux live provenită de la camera web, iar alta este șablonul de imagine pe baza căruia ne vom potrivi cu imaginea noastră. Apoi ne schimbăm imaginea webcam-ului în tonuri de gri și apoi inițializăm detectorul ORB și îl setăm aici la 1000 de puncte cheie și parametrii de scalare de 1.2. puteți juca cu ușurință cu acești parametri, apoi puteți detecta punctele cheie (kp) și descriptorii (des) atât pentru imagini, cât și pentru al doilea parametru pe care îl definim în funcția de detectare și calculare este NICIUL , solicită sau nu masca de imagine și o negăm aici.
Apoi treceți la detector anterior, am folosit anterior potrivirea bazată pe FLANN, dar aici vom folosi BFMatcher, iar în interiorul BFMatcher definim doi parametri, unul este NORM_HAMMING și altul este crossCheck a cărui valoare este TRUE.
Apoi calculați meciurile potrivirile dintre aceste două imagini folosind descriptorii definiți mai sus, care în toate returnează numărul de meciuri, deoarece aceste meciuri nu sunt aproximative și, prin urmare, nu este necesar să faceți testul raportului Lowe, în schimb, sortăm meciurile în funcție de distanță, cel puțin cu cât distanța este mai bună (aici distanța înseamnă distanță între puncte), iar la final returnăm numărul de meciuri folosind funcția de lungime.
Și în funcția principală setăm pragul la o valoare mult mai mare, deoarece detectorul de orburi generează mult zgomot.
Acum să ne uităm la cod pentru detectarea bazată pe ORB
import cv2 import numpy ca np def ORB_detector (new_image, image_template): # Funcție care compară imaginea de intrare cu șablonul # Apoi returnează numărul de potriviri ORB dintre ele image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) # Creați un detector ORB cu 1000 puncte cheie cu un factor de piramidă de scalare de 1,2 orb = cv2.ORB_create (1000, 1,2) # Detectează punctele cheie ale imaginii originale (kp1, des1) = orb.detectAndCompute (imagine1, Niciuna) # Detectează punctele cheie ale imaginii rotite (kp2, des2) = orb.detectAndCompute (image_template, None) # Create matcher # Notă că nu mai folosim potrivirea bazată pe Flann bf = cv2.BFMatcher (cv2.NORM_HAMMING, crossCheck = True) # Faceți potriviri potrivite = bf.match (des1, des2) # Sortați potrivirile în funcție de distanță. Cea mai mică distanță # este mai bună potriviri = sortate (potriviri, cheie = lambda val: val.distance) return len (potriviri) cap = cv2.VideoCapture (0) # Încărcați șablonul nostru de imagine, aceasta este imaginea noastră de referință image_template = cv2.imread ('phone.jpg', 0) # image_template = cv2.imread ('images / kitkat.jpg', 0) în timp ce adevărat: # Ia camera web imagini ret, cadru = cap.read () # Ia înălțimea și lățimea cadrului webcameră înălțime, width = frame.shape # Definiți dimensiunile casetei ROI (Rețineți că unele dintre aceste lucruri ar trebui să fie în afara buclei) top_left_x = int (width / 3) top_left_y = int ((înălțime / 2) + (înălțime / 4)) bottom_right_x = int ((lățime / 3) * 2) bottom_right_y = int ((înălțime / 2) - (înălțime / 4)) # Desenați fereastra dreptunghiulară pentru regiunea de interes cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) # Decupați fereastra de observație definită mai sus decupate = cadru # Flip orientare cadru orizontal cadru = cv2.flip (cadru, 1) # Obțineți numărul de meciuri ORB potrivite = ORB_detector (decupat, model_imagine) # Afișați șirul de stare care afișează nr. of matches output_string = "Matches =" + str (matches) cv2.putText (frame, output_string, (50,450), cv2.FONT_HERSHEY_COMPLEX, 2, (250,0,150), 2) # Pragul nostru pentru a indica detecția obiectului # Pentru imagini noi sau condiții de iluminare poate fi necesar să experimentați puțin # Notă: Detectorul ORB pentru a obține primele 1000 de meciuri, 350 este în esență un prag minim de potrivire de 35% = 250 # Dacă meciurile depășesc prag atunci obiectul a fost detectat dacă se potrivește> prag: cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (frame, 'Object Found', (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow ('Object Detector folosind ORB', frame) dacă cv2.waitKey (1) == 13: # 13 este tasta Enter pauză capac.release () cv2.destroyAllWindows ()
Histograma gradienților orientați (HOG)
Acum să vorbim despre un descriptor diferit, care este Histograma orientată a gradienților (HOG).
HOG-urile sunt descriptori destul de interesanți și utili și sunt folosiți pe scară largă și cu succes pentru detectarea obiectelor, așa cum am văzut anterior descriptorii de imagine precum SIFT și ORB unde trebuie să calculăm puncte cheie și apoi trebuie să calculăm descriptori din acele puncte cheie, HOG face acest proces diferit. Ea reprezintă obiecte ca un singur vector caracteristic, spre deosebire de un set de vectori de trăsături unde fiecare reprezintă un segment al imaginii. Înseamnă că avem o singură caracteristică vectorială pentru întreaga imagine.
Este calculat de un detector de ferestre glisante peste o imagine, unde un descriptor HOG este calculat pentru fiecare poziție. Și apoi fiecare poziție este combinată pentru un singur vector de caracteristică.
La fel ca SIFT, scala imaginii este ajustată prin piramidă.
Anterior am folosit potrivitori precum FLANN și BFMatcher, dar HOG-urile o fac diferit cu ajutorul clasificatorilor SVM (suport vector machine), unde fiecare descriptor HOG care este calculat este alimentat către un clasificator SVM pentru a determina dacă obiectul a fost găsit sau nu.
Iată linkul către o lucrare excelentă a lui Dalal & Triggs despre utilizarea HOG-urilor pentru detectarea umană:
Histograma gradienților orientați (HOG), pas cu pas:
Înțelegerea HOG-urilor ar putea fi destul de complexă, dar aici ne vom ocupa doar de teoria HOG-urilor fără a intra mai adânc în matematica legată de aceasta.
Deci, să facem această imagine, este puțin pixelată, iar în colțul superior este o casetă de 8x8 pixeli aici, deci în această casetă calculăm vectorul de gradient sau orientările marginilor la fiecare pixel. Deci, înseamnă că în această casetă calculăm vectorul de gradient al imaginii pixelilor din interiorul casetei (acestea sunt un fel de direcție sau de flux al intensității imaginii în sine), iar acest lucru generează 64 (8 x 8) vectori de gradient care sunt apoi reprezentați ca o histogramă. Deci, imaginați-vă o histogramă care reprezintă fiecare vector de gradient. Deci, dacă toate punctele sau intensitățile se află într-o singură direcție, histograma pentru acea direcție să presupunem 45 de grade, histograma ar avea vârful la 45 de grade.
Deci, ceea ce facem acum este să împărțim fiecare celulă în coșuri unghiulare, unde fiecare coș corespunde unei direcții de gradient (de exemplu, x, y). În hârtia Dalal și Triggs, au folosit 9 coșuri 0-180 ° (20 ° fiecare coș). Aceasta reduce efectiv 64 de vectori la doar 9 valori. Deci, ceea ce am făcut este să reducem dimensiunea, dar să păstrăm toate informațiile cheie necesare.
Următorul pas în calcularea porcilor este normalizarea, normalizăm gradienții pentru a asigura invarianța la modificările de iluminare, adică Luminozitate și contrast.
În această imagine, valorile intensității sunt afișate în pătrat în funcție de direcția respectivă și toate au o diferență de 50 între ele
∆ H = 50, ∆ v = 50; │∆│ = √50 2 +50 = 70,72, 70,72 / 100 = 0,707
Împărțim vectorii la mărimile gradientului obținem 0,707 pentru toți, aceasta este normalizarea.
În mod similar, dacă schimbăm intensitatea sau schimbăm contrastul, obținem valorile de mai jos.
∆ H = 50, ∆ v = 50; │∆│ = √50 2 +50 = 70,72, 70,72 / 100 = 0,707; ∆ H = 100, ∆ v = 100; │∆│ = √100 2 +100 = 141,42, 141,42 / 100 = 1,41
Normalizarea nu are loc la nivel de celulă, ci are loc la nivel de bloc, deci aici blocurile sunt practic un grup de 4 celule, acest lucru ținând cont de blocurile învecinate, astfel încât să se normalizeze luând în considerare segmente mai mari ale imaginii.
Acum să ne uităm la cod
import numpy as np import cv2 import matplotlib.pyplot as plt # Încarcă imaginea apoi imaginea în tonuri de gri = cv2.imread ('elephant.jpg') gri = cv2.cvtColor (imagine, cv2.COLOR_BGR2GRAY) # Arată imaginea originală cv2.imshow (' Intrare imagine ', imagine) cv2.waitKey (0) #definirea parametrilor, dimensiunea celulei și dimensiunea blocului # hxw în pixeli cell_size = (8, 8) # hxw în celule block_size = (2, 2) # numărul de coșuri de orientare nbins = 9 # Utilizarea OpenCV HOG Descriptor # winSize este dimensiunea imaginii decupate la un multiplu al dimensiunii celulei hog = cv2.HOGDescriptor (_winSize = (gray.shape // cell_size * cell_size, gray.shape // cell_size * cell_size), _blockSize = (block_size * cell_size, block_size * cell_size), _blockStride = (cell_size, cell_size), _cellSize = (cell_size, cell_size), _nbins = nbins) # Creați o formă de matrice numpy pe care o folosim pentru a crea hog_features n_cells = (gray.shape // cell_size, gray.shape // cell_size) # Mai întâi indexăm blocurile după rânduri. # hog_feats conține acum amplitudinile gradientului pentru fiecare direcție, # pentru fiecare celulă a grupului său pentru fiecare grup. Indexarea se face pe rânduri, apoi pe coloane. hog_feats = hog.compute (gri).reshape (n_cells - block_size + 1, n_cells - block_size + 1, block_size, block_size, nbins).transpose ((1, 0, 2, 3, 4)) # Creați matricea noastră de gradienți cu dimensiuni nbin pentru a stoca orientări de gradient gradienți = np.zeros ((n_cells, n_cells, nbins)) # Creați un array de dimensiuni cell_count = np.full ((n_cells, n_cells, 1), 0, dtype = int) # Block Normalization for off_y in range (block_size): for off_x in range (block_size): gradients - block_size + off_y + 1, off_x: n_cells - block_size + off_x + 1] + = \ hog_feats cell_count - block_size + off_y + 1, off_x: n_cells - block_size + off_x + 1] + = 1 # Gradients medii gradients / = cell_count # Plot HOGs using Matplotlib # angle is 360 / nbins * direction color_bins = 5 plt.pcolor (gradients) plt.gca (). invert_yaxis () plt.gca (). set_aspect ('egal', ajustabil = 'cutie') plt.colorbar () plt.show () cv2.destroyAllWindows ()
Imaginea arată cum este reprezentată imaginea de intrare ca reprezentare HOG.
Clasificatori în cascadă HAAR
După cum sa discutat anterior, putem extrage caracteristici dintr-o imagine și le putem utiliza pentru a clasifica sau detecta obiecte.
Ce sunt clasificatoarele HAAR Cascade?
O metodă de detectare a obiectelor care introduce caracteristici Haar într-o serie de clasificatoare (cascadă) pentru a identifica obiectele dintr-o imagine. Ei sunt instruiți pentru a identifica un tip de obiect, cu toate acestea, putem folosi mai multe dintre ele în paralel, de exemplu, detectarea ochilor și a fețelor împreună.
Clasificatori HAAR Explicați:
Clasificatorii HAAR sunt instruiți folosind o mulțime de imagini pozitive (adică imagini cu obiectul prezent) și
imagini negative (adică imagini fără obiectul prezent).
Odată ce avem aceste imagini, extragem apoi caracteristici folosind ferestre glisante de blocuri dreptunghiulare. Aceste caracteristici (caracteristici HAAR) au o singură valoare și sunt calculate prin scăderea sumei intensităților pixelilor sub dreptunghiurile albe din dreptunghiurile negre.
Cu toate acestea, acesta este un număr ridicol de calcule, chiar și pentru o fereastră de bază de 24 x 24 pixeli (180.000 de caracteristici generate).
Astfel, cercetătorii au conceput o metodă numită Imagini Integrale care a calculat acest lucru cu patru referințe matrice. Cu toate acestea, au încă 180.000 de funcții și majoritatea nu au adăugat nicio valoare reală.
Boosting a fost apoi utilizat pentru a determina cele mai informative caracteristici, cu Freund & Schapire AdaBoost și a găsit cele mai multe caracteristici informative din imagine. Stimularea este procesul prin care folosim clasificatori slabi pentru a construi clasificatori puternici, pur și simplu prin atribuirea unor penalități mai grele la clasificări incorecte. Reducerea celor 180.000 de funcții la 6000, care este încă destul de puține caracteristici.
În aceste 6000 de funcții, unele vor fi mai informative decât altele. Deci, dacă am folosit cele mai informative caracteristici pentru a verifica mai întâi dacă regiunea poate avea potențial o față (falsurile pozitive nu vor fi mare lucru). Acest lucru elimină necesitatea de a calcula toate cele 6000 de funcții simultan. Acest concept se numește Cascada Clasificatorilor - pentru detectarea feței, metoda Viola Jones a folosit 38 de etape.
Detectarea feței și a ochilor
Deci, după ce am câștigat unele cunoștințe teoretice despre cascadele HAAR, vom implementa în cele din urmă, astfel încât, pentru a face lucrurile destul de clare, vom rupe lecțiile în părți, mai întâi am detecta fața frontală după care ne vom deplasa pentru a detecta fața frontală cu ochii și în cele din urmă am face detectarea în direct a feței și a ochilor prin intermediul camerei web.
Deci, pentru aceasta, vom folosi clasificatori pre-instruiți care au fost furnizați de OpenCV ca fișiere.xml, xml înseamnă limbaj extensibil de marcare, acest limbaj este folosit pentru a stoca o cantitate mare de date, chiar și puteți crea o bază de date pe ea.
Puteți avea accesul acestor clasificatoare la acest link .
Detectare facială
Să încercăm detectarea feței frontale, puteți avea acces aici pentru cascada detectorului feței frontale. Doar extrageți fișierul zip pentru a obține fișierul xml.
import numpy ca np import cv2 # Indicăm funcția CascadeClassifier a OpenCV către locul unde este stocat clasificatorul nostru # (format de fișier XML), nu uitați să păstrați codul și clasificatorul în același folder face_cascade = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') # Încărcare imaginea noastră apoi o convertește în tonuri de gri image = cv2.imread ('Trump.jpg') gri = cv2.cvtColor (imagine, cv2.COLOR_BGR2GRAY) # Clasificatorul nostru returnează ROI-ul feței detectate sub formă de tuplu # Stochează stânga sus coordonate și coordonatele din dreapta jos # returnează lista listelor, care sunt locația diferitelor fețe detectate. faces = face_cascade.detectMultiScale (gri, 1,3, 5) # Când nu s-au detectat fețe, face_classifier revine și tuplul gol dacă fețele este (): print ("Nu s-au găsit fețe") # Iterăm prin matricea noastră de fețe și desenăm un dreptunghi # peste fiecare față în fețe pentru (x, y, w, h) în fețe: cv2.rectangle (image, (x, y), (x + w, y + h), (127,0,255), 2) cv2.imshow ('Face Detection', image) cv2.waitKey (0) cv2.destroyAllWindows ()
Acum să combinăm detectarea feței și a ochilor împreună, puteți avea acces la cascada detectorului de ochi în același fișier zip.
import numpy as np import cv2 face_classifier = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') eye_classifier = cv2.CascadeClassifier ('haarcascade_eye.xml') img = cv2.imread ('Trump.jpg') gray = cv2.cvtCol cv2.COLOR_BGR2GRAY) faces = face_classifier.detectMultiScale (gri, 1.3, 5) # Atunci când nu se detectează fețe, face_classifier revine și tuplul gol dacă fețele este (): print ("No Face Found") pentru (x, y, w, h) în fețe: cv2.rectangle (img, (x, y), (x + w, y + h), (127,0,255), 2) cv2.imshow ('img', img) roi_gray = gri roi_color = img eyes = eye_classifier.detectMultiScale (roi_gray) cv2.waitKey (0) for (ex, ey, ew, eh) in eyes: cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (255,255,0), 2) cv2.imshow ('img', img) cv2.waitKey (0) cv2.destroyAllWindows () cv2.waitKey (0)
Deci, acest cod este la fel de mult ca și codul pentru detectarea feței, dar aici am adăugat cascade de ochi și metodă pentru a le detecta, după cum puteți vedea, am ales versiunea la scară gri a feței ca parametru pentru detectMultiScale pentru ochii, ceea ce ne aduce la reducerea calculului, deoarece vom detecta ochii doar în acea zonă.
Detectarea Live Face și Eye
Deci, până acum am făcut detectarea feței și a ochilor, acum să implementăm același lucru cu fluxul video live de pe camera web. În acest sens vom face aceeași detectare a feței și a ochilor, dar de data aceasta o vom face pentru transmisia live din camera web. În cea mai mare parte a aplicației, ți-ai găsi fața evidențiată cu o cutie în jurul ei, dar aici am făcut ceva diferit în care ai găsi fața tăiată și ochii s-ar identifica numai în asta.
Așadar, aici importăm atât clasificarea feței, cât și a ochilor și am definit o funcție pentru efectuarea tuturor procesărilor pentru detectarea feței și a ochilor. Și după aceea a început fluxul webcam și a apelat funcția de detector de față pentru a detecta fața și ochii. Parametrul pe care îl definim în interiorul funcției de detector de față sunt imaginile continue din fluxul cam web live
import cv2 import numpy as np face_classifier = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') eye_classifier = cv2.CascadeClassifier ('haarcascade_eye.xml') def face_detector (img, size = 0.5): # Convertiți imaginea în greycv (img, cv2.COLOR_BGR2GRAY) faces = face_classifier.detectMultiScale (gri, 1.3, 5) dacă fețele sunt (): returnează img pentru (x, y, w, h) în fețe: x = x - 50 w = w + 50 y = y - 50 h = h + 50 cv2.rectangle (img, (x, y), (x + w, y + h), (255,0,0), 2) roi_gray = gri roi_color = img eyes = eye_classifier.detectMultiScale (roi_gray) pentru (ex, ey, ew, eh) în ochi: cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (0,0,255), 2) roi_color = cv2.flip (roi_color, 1) return roi_color cap = cv2.VideoCapture (0) în timp ce este adevărat: ret, frame = cap.read () cv2.imshow („Our Face Extractor”, face_detector (frame)) if cv2.waitKey (1) == 13: # 13 este Enter Key break cap.release () cv2.destroyAllWindows ()
Reglarea clasificatoarelor în cascadă
Parametrii definiți în detectMultiScale, diferiți de imaginea de intrare, au următoarea semnificație
clasificatorul nostru. detectMultiScale (imagine de intrare, factor de scală, vecini min.)
- Scale Factor Specifică cât reducem dimensiunea imaginii de fiecare dată când scalăm. De exemplu, în detectarea feței, de obicei folosim 1.3. Aceasta înseamnă că reducem imaginea cu 30% de fiecare dată când este scalată. Valorile mai mici, cum ar fi 1.05, vor dura mai mult timp pentru a calcula, dar vor crește rata de detectare.
- Vecini min. Specifică numărul de vecini pe care ar trebui să-i aibă fiecare fereastră potențială pentru a o considera o detectare pozitivă. De obicei setat între 3-6. Acționează ca setare a sensibilității, valori scăzute uneori detectează fețe multiple pe o singură față. Valorile ridicate vor asigura mai puține pozitive false, dar este posibil să vă lipsească unele fețe.
Detectarea autoturismelor și pietonilor în videoclipuri
Acum vom detecta pietonii și mașinile în videoclipuri folosind cascadele HAAR, dar în cazul în care nu se încarcă niciun videoclip și codul se compilează fără o eroare, trebuie să urmați pașii următori:
Dacă nu se încarcă videoclipuri după ce ați rulat codul, poate fi necesar să copiați opencv_ffmpeg.dl din : opencv \ sources \ 3rdparty \ ffmpeg pentru a-l lipi acolo unde este instalat python, de exemplu C: \ Anaconda2
Odată ce a fost copiat, va trebui să redenumiți fișierul în funcție de versiunea de OpenCV pe care o utilizați.eg dacă utilizați OpenCV 2.4.13, apoi redenumiți fișierul ca: opencv_ffmpeg2413_64.dll sau opencv_ffmpeg2413.dll (dacă folosind o mașină X86) opencv_ffmpeg310_64.dll sau opencv_ffmpeg310.dll (dacă utilizați o mașină X86)
Pentru a afla unde este instalat python.exe, trebuie doar să rulați aceste două linii de cod, acesta ar imprima locația în care este instalat python.
import sys print (sys.executable)
Acum, dacă ați făcut acești pași cu succes, să trecem la codul pentru detectarea pietonilor, Puteți avea cascada pentru detectarea pietonilor și din fișierul zip atașat aici.
import cv2 import numpy as np # Create our body classifier body_classifier = cv2.CascadeClassifier ('haarcascade_fullbody.xml') # Inițiază captura video pentru fișierul video, aici folosim fișierul video în care ar fi detectați pietonii cap = cv2.VideoCapture ('walking.avi') # Buclă odată ce videoclipul este încărcat cu succes în timp ce cap.isOpened (): # Citind fiecare cadru al retretului video , frame = cap.read () # aici redimensionăm cadrul, la jumătate din dimensiunea sa, facem pentru a accelera clasificarea #, deoarece imaginile mai mari au mult mai multe ferestre pentru a glisa, așa că, în general, reducem rezoluția #de videoclip la jumătate, ceea ce indică 0.5 și folosim, de asemenea, o metodă de interpolare mai rapidă, care este #interlinear frame = cv2.resize (frame, None, fx = 0.5, fy = 0.5, interpolation = cv2.INTER_LINEAR) gri = cv2. cvtColor (cadru, cv2.COLOR_BGR2GRAY) # Treceți cadru la corpurile noastre de clasificare a corpului = body_classifier.detectMultiScale (gri, 1.2, 3) # Extrageți casete de delimitare pentru orice corpuri identificate pentru (x, y, w, h) în corpuri: cv2. dreptunghi (cadru, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow („Pietoni”, cadru) dacă cv2.waitKey (1) == 13: # 13 este Enter Key break cap.release () cv2.destroyAllWindows ()
După ce am detectat cu succes pietonii în video, să trecem la codul pentru detectarea mașinii. Puteți avea cascada pentru detectarea pietonilor de aici.
import cv2 import time import numpy as np # Creați clasificatorul corpului nostru car_classifier = cv2.CascadeClassifier ('haarcascade_car.xml') # Inițiați captura video pentru fișierul video cap = cv2.VideoCapture ('cars.avi') # Buclați odată ce videoclipul este reușit încărcat în timp ce cap.isOpened (): time.sleep (.05) # Citește primul cadru ret, frame = cap.read () gri = cv2.cvtColor (cadru, cv2.COLOR_BGR2GRAY) # Trece cadru la clasificatorul nostru de mașini cars = car_classifier.detectMultiScale (gri, 1.4, 2) # Extrageți casetele de delimitare pentru orice corpuri identificate pentru (x, y, w, h) în mașini: cv2.rectangle (frame, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow („Mașini”, cadru) dacă cv2.waitKey (1) == 13: # 13 este Enter Key break cap.release () cv2.destroyAllWindows ()
Ați observat că am adăugat time.sleep (.05) , este doar o întârziere a ratei cadrelor, astfel încât să puteți confirma că toate mașinile sunt corect identificate sau îl puteți elimina cu ușurință doar adăugând o etichetă de comentariu.
Acest articol este trimis de la Master Computer Vision ™ OpenCV4 în Python cu cursul Deep Learning pe Udemy, creat de Rajeev Ratan, abonați-l pentru a afla mai multe despre Computer Vision și Python.