- Detecció d'objectes mitjançant SIFT
- Detecció d'objectes mitjançant ORB
- Histograma de gradients orientats (HOG's)
- Histograma de gradients orientats (HOG's), pas a pas:
- Classificadors en cascada HAAR
- Detecció de cara i ulls
- Detecció de cares i ulls en viu
- Tuning de classificadors de cascades
- Detecció de vehicles i vianants en vídeos
Vam començar amb la instal·lació de Python OpenCV a Windows i fins ara vam fer alguns processos bàsics d'imatge, segmentació d'imatges i detecció d'objectes mitjançant Python, que es detallen a continuació als tutorials:
- Introducció a Python OpenCV: instal·lació i processament bàsic d’imatges
- Manipulacions d’imatges a Python OpenCV (primera part)
- Manipulacions d’imatges a OpenCV (part 2)
- Segmentació d'imatges mitjançant OpenCV: extracció d'àrees específiques d'una imatge
També vam aprendre sobre diversos mètodes i algorismes per a la detecció d’objectes on es van identificar alguns punts clau per a cada objecte mitjançant diferents algoritmes. En aquest tutorial utilitzarem aquests algoritmes per detectar objectes de la vida real, aquí utilitzaríem SIFT i ORB per a la detecció.
Detecció d'objectes mitjançant SIFT
Aquí la detecció d'objectes es farà mitjançant una transmissió de càmera web en directe, de manera que si reconeix l'objecte esmentarà l'objecte trobat. En el codi, la funció principal la juga la funció anomenada detector SIFT, la majoria del processament la realitza aquesta funció.
I a l’altra meitat del codi, comencem obrint el flux de càmera web i, a continuació, carregem la plantilla d’imatge, és a dir, la imatge de referència, és a dir, el programa està realment mirant a través del flux de càmera web.
A continuació, capturem contínuament les imatges del flux de càmera web amb l'ajut d'un bucle infinit mentre que capturem l'alçada i l'amplada corresponents del marc de la càmera web i, a continuació, definim els paràmetres del quadre de la regió d'interès (ROI) en què el nostre objecte pot encabir-se prenent l’alçada i l’amplada corresponents del marc de la càmera web. I després dibuixem el rectangle a partir dels paràmetres de ROI que havíem definit anteriorment. A continuació, retalleu el rectangle i introduïu-lo a la part del codi del detector SWIFT.
Ara, el detector SIFT té bàsicament dues entrades, una és la imatge retallada i l’altra és la plantilla d’imatge que hem definit prèviament i ens dóna algunes coincidències, de manera que les coincidències són bàsicament el nombre d’objectes o punts clau que són similars a la imatge retallada. i la imatge objectiu. A continuació, definim un valor llindar per a les coincidències, si el valor de les coincidències és superior al llindar, posem la imatge que es troba a la nostra pantalla amb color verd del rectangle ROI.
Ara tornem a la part principal del codi, la funció que s’anomena detector SIFT; pren l’entrada com a dues imatges; una és la imatge on busca l’objecte i l’altra és l’objecte amb el qual intentem fer coincidir. a (plantilla d'imatge). A continuació, escaleu els grisos la primera imatge i definiu la plantilla d'imatge com a segona imatge. A continuació, creem un objecte detector SIFT i executem la funció de detecció i càlcul OpenCV SIFT, de manera que es detectin els punts clau i es calculin els descriptors, els descriptors són bàsicament els vectors que emmagatzemen la informació sobre els punts clau, i és molt important que fem la coincidència entre els descriptors de les imatges.
I, a continuació, definiu el combinador basat en FLANN, no entrem en la teoria matemàtica de la coincidència que hi ha al darrere, però podeu fer-ne fàcilment Google. En primer lloc, definiu l’índex kdtree a zero i, a continuació, establim l’índex i els paràmetres de cerca en el format de diccionari, només definim l’algoritme que farem servir, que és KDTREE, i el nombre d’arbres que farem servir, més arbre fem servir com més complicat es fa i més lent. I en el paràmetre de cerca definiu el nombre de comprovacions, que és bàsicament el nombre de coincidències que completarà.
I, a continuació, creeu el nostre objecte d'aparellament basat en FLANN carregant el paràmetre que hem definit prèviament, que són paràmetres d'índex i paràmetres de cerca, i basat en això, creeu el nostre aparellador basat en FLANN, que és un aparellador KNN on KNN és el veí més proper a K, bàsicament és una forma en què busquem coincidents i descriptors més propers i fem la coincidència amb la constant d’inicialització k. Ara aquest aparellador basat en FLANN ens retorna el nombre de coincidències que obtenim.
La coincidència basada en FLANN és només una aproximació, de manera que per augmentar la precisió de l’assemblador basat en FLANN realitzem una prova de ràtio de Lowe i el que fa és buscar les coincidències de l’assemblador basat en flann knn i definir alguns paràmetres matricials que és la distància aquí, per a la qual la distància és una funció numpy i, un cop compleix els criteris, afegiu les coincidències a les coincidències bones i retorna les coincidències bones trobades, de manera que el flux de vídeo en directe indica el nombre de coincidències trobades a la cantonada de la pantalla.
Vegem ara el codi de la descripció anterior:
import cv2 import numpy as np def sift_detector (new_image, image_template): # Funció que compara la imatge d’entrada amb la plantilla # A continuació, retorna el nombre de coincidències SIFT entre elles image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) image2 = image_template # Create SIFT detector object #sift = cv2.SIFT () sift = cv2.xfeatures2d.SIFT_create () # Obteniu els punts clau i els descriptors mitjançant SIFT keypoints_1, descriptors_1 = sift.detectAndCompute (image1, None) keypoints_2, descriptors_2 = sift.det Cap) # Definiu paràmetres per al nostre Flann Matcher FLANN_INDEX_KDTREE = 0 index_params = dict (algorisme = FLANN_INDEX_KDTREE, arbres = 3) search_params = dict (checks = 100) # Creeu l'objecte Flann Matcher flann = cv2.FlannBasedMatcher (index_params, search_params) # Obteniu coincidències amb el mètode K-Neighbor més proper # el resultat "coincideix" és el nombre de coincidències similars que es troben a les dues coincidències d' imatges = flann.knnMatch (descriptors_1, descriptors_2, k = 2) # Emmagatzemar coincidències bones utilitzant la prova de relació Lowe's good_matches = per m, n en coincidències: si m.distance <0,7 * n.distance: good_matches.append (m) return len (good_matches) cap = cv2.VideoCapture (0) # Carregueu la nostra plantilla d'imatge, aquesta és la nostra imatge de referència image_template = cv2.imread ('phone.jpg', 0) mentre és True: # Obteniu imatges de càmeres web ret, frame = cap.read () # Obteniu l'alçada i l'amplada de la càmera web frame height, width = frame.shape # Defineix les dimensions de la caixa 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)) # Dibuixa una finestra rectangular per a la nostra regió d'interès cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) # Finestra de retallada d'observació que hem definit anteriorment retallada = marc # Flip l'orientació del marc horitzontalment frame = cv2.flip (frame, 1) # Obteniu el nombre de coincidències SIFT coincideix = sift_detector (retallat, plantilla_imatge) # Mostra la cadena d'estat que mostra el núm. de coincidències cv2.putText (frame, str (matches), (450.450), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 1) # El nostre llindar per indicar la detecció de l'objecte # Utilitzem 10 ja que el detector SIFT retorna pocs falsos positius llindar = 10 # Si les coincidències superen el nostre llindar, l'objecte s'ha detectat si coincideix> llindar: cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (frame, "Objecte trobat", (50,50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow ("Detector d'objectes mitjançant SIFT", marc) si cv2.waitKey (1) == 13: # 13 és la tecla Retorn ruptura cap.release () cv2.destroyAllWindows ()
Detecció d'objectes mitjançant ORB
La detecció d’objectes mitjançant SIFT és pràcticament divertida i correcta, ja que genera un nombre de coincidències molt precís basat en punts clau, tot i que és patentat i això fa que sigui difícil utilitzar-lo per a aplicacions comercials, l’altre sortida és l’algorisme ORB per a la detecció d'objectes.
De manera similar al mètode de detecció d’objectes per SIFT en què vam dividir el programa en dues parts, aquí es seguirà el mateix.
En primer lloc, definim la funció ORB_detector que pren dues entrades: una és la imatge de transmissió en directe provinent de la càmera web i l’altra és la plantilla d’imatge sobre la base de la qual farem coincidir la nostra imatge. A continuació, fem escala de grisos la nostra imatge de càmera web i, a continuació, inicialitzem el nostre detector ORB, i l'establim aquí en 1000 punts clau i paràmetres d'escala de 1.2. podeu jugar fàcilment amb aquests paràmetres i, a continuació, detectar els punts clau (kp) i els descriptors (des) tant per a les imatges com per al segon paràmetre que definim a la funció detectANDCompute és CAP, sol·licita o no l’ús de màscara d’imatge i aquí ho estem negant.
A continuació, moveu-vos al detector prèviament que hem estat utilitzant el coincident basat en FLANN, però aquí farem servir BFMatcher i dins de BFMatcher definirem dos paràmetres: un és NORM_HAMMING i l’altre és el crossCheck el valor del qual és TRUE.
A continuació, calculeu les coincidències de les coincidències entre aquestes dues imatges amb els descriptors definits anteriorment, que, en tots els casos, retorna el nombre de coincidències, ja que aquestes coincidències no són aproximatives i, per tant, no cal fer la prova de la ràtio de Lowe; en lloc d'això, ordenem les coincidències en funció de la distància, com més mínima sigui la distància més bona del partit (aquí la distància significa distància entre els punts) i, al final, retornem el nombre de coincidències mitjançant la funció de longitud.
I a la funció principal establim el llindar a un valor molt superior, ja que el detector d’orbes genera molt de soroll.
Vegem ara el codi per a la detecció basada en ORB
import cv2 import numpy as np def ORB_detector (new_image, image_template): # Funció que compara la imatge d’entrada amb la plantilla # A continuació, retorna el nombre de coincidències ORB entre elles image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) # Crea un detector ORB amb 1000 punts clau amb un factor piramidal d’escala d’1,2 orb = cv2.ORB_create (1000, 1,2) # Detecta els punts clau de la imatge original (kp1, des1) = orb.detectAndCompute (imatge1, Cap) # Detecta els punts clau de la imatge girada (kp2, des2) = orb.detectAndCompute (image_template, None) # Create matcher # Nota ja no fem servir coincidències basades en Flann bf = cv2.BFMatcher (cv2.NORM_HAMMING, crossCheck = True) # Feu coincidències coincidents = bf.match (des1, des2) # Ordeneu les coincidències en funció de la distància. La distància mínima # és millor coincidències = ordenades (coincidències, clau = lambda val: val.distance) retorn len (coincidències) cap = cv2.VideoCapture (0) # Carregueu la nostra plantilla d'imatge, aquesta és la nostra imatge de referència image_template = cv2.imread ('phone.jpg', 0) # image_template = cv2.imread ('images / kitkat.jpg', 0) mentre és True: # Obteniu imatges de càmeres web ret, frame = cap.read () # Obteniu l'alçada i l'amplada de l' alçada del marc de la càmera web , width = frame.shape # Defineix les dimensions del quadre de ROI (tingueu en compte que algunes d'aquestes coses haurien d'estar fora del bucle) 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)) # Dibuixa una finestra rectangular per a la nostra regió d’interès cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) # Finestra de retall d’observació que hem definit anteriorment retallada = frame # Invertir l’ orientació del frame horizontalment frame = cv2.flip) # Obteniu el nombre de coincidències ORB coincidents = ORB_detector (retallat, image_template) # Mostra la cadena d'estat que mostra el núm. of matches output_string = "Matches =" + str (matches) cv2.putText (frame, output_string, (50,450), cv2.FONT_HERSHEY_COMPLEX, 2, (250,0,150), 2) # El nostre llindar per indicar la detecció de l'objecte. # Per a imatges noves o condicions d'il·luminació, és possible que hàgiu d'experimentar una mica. # Nota: El detector ORB per obtenir els 1000 millors partits, 350 és essencialment un llindar de coincidència mínim del 35% = 250 # llindar l'objecte s'ha detectat si coincideix> llindar: cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (frame, 'Object Object Found', (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow ('Detector d'objectes mitjançant ORB', marc) si cv2.waitKey (1) == 13: # 13 és el límit de salt de tecla Enter .release () cv2.destroyAllWindows ()
Histograma de gradients orientats (HOG's)
Ara parlem d’un descriptor diferent que és l’Histograma de gradients orientats (HOG).
Els HOG són descriptors pràcticament genials i útils i s’utilitzen àmpliament i amb èxit per a la detecció d’objectes, com s’ha vist anteriorment, els descriptors d’imatges com SIFT i ORB, on hem de calcular punts clau i després hem de calcular descriptors a partir d’aquests punts clau, els HOG fan aquest procés de manera diferent. Es representa objectes com un únic vector de característiques en comparació amb un conjunt de vectors de característiques, on cada un representa un segment de la imatge. Vol dir que tenim una funció vectorial única per a tota la imatge.
Es calcula mitjançant un detector de finestra corredissa sobre una imatge, on es descriu un descriptor HOG per a cada posició. I després, cada posició es combina per a un vector de característica única.
Igual que SIFT, l’escala de la imatge s’ajusta per piràmide.
Anteriorment hem utilitzat aparelladors com FLANN i BFMatcher, però els HOG ho fan de manera diferent amb l'ajut dels classificadors SVM (màquina de vector de suport), on cada descriptor HOG que es calcula s'alimenta a un classificador SVM per determinar si l'objecte s'ha trobat o no.
Aquí teniu l’enllaç a un gran document de Dalal & Triggs sobre l’ús de HOGs per a la detecció humana:
Histograma de gradients orientats (HOG's), pas a pas:
Comprendre els HOG podria ser bastant complex, però aquí només tractarem la teoria dels HOG sense aprofundir en les matemàtiques que hi estan relacionades.
Prenem aquesta imatge que està una mica pixelada, i a la cantonada superior hi ha un quadre de 8x8 píxels, de manera que en aquest quadre calculem el vector de degradat o les orientacions de les vores a cada píxel. Per tant, vol dir que en aquest quadre calculem el vector de gradient de la imatge dels píxels dins del quadre (són una mena de direcció o flux de la pròpia intensitat de la imatge), i això genera 64 (8 x 8) vectors de gradient que es representen després com un histograma. Imagineu-vos, doncs, un histograma que representi cada vector de gradient. Per tant, si tots els punts o intensitats estiguessin en una direcció, l’histograma d’aquesta direcció diguem-ne 45 graus, l’histograma tindria un màxim a 45 graus.
Per tant, el que fem ara és dividir cada cel·la en contenidors angulars, on cada contenidor correspon a una direcció de gradient (per exemple, x, y). Al paper Dalal i Triggs, van utilitzar 9 papereres de 0 a 180 ° (20 ° cada paperera). Això redueix efectivament 64 vectors a només 9 valors. Així, doncs, el que hem fet és reduir la mida però mantenir tota la informació clau que es necessita.
El següent pas en el càlcul del porc és la normalització, normalitzem els gradients per assegurar la invariancia als canvis d’il·luminació, és a dir, Lluminositat i Contrast.
En aquesta imatge, els valors d'intensitat es mostren al quadrat segons la direcció respectiva i tots tenen una diferència de 50 entre si
∆ H = 50, ∆ v = 50; │∆│ = √50 2 +50 = 70,72, 70,72 / 100 = 0,707
Dividim els vectors per les magnituds del gradient que obtenim 0,707 per a tots, això és normalització.
De la mateixa manera, si canviem la intensitat o canviem el contrast, obtindrem els valors següents.
∆ 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
La normalització no té lloc a nivell de cel·la, sinó que es fa a nivell de bloc, de manera que aquí els blocs són bàsicament un grup de 4 cel·les, això té en compte els blocs veïns, de manera que es normalitzen tenint en compte segments més grans de la imatge.
Vegem ara el codi
import numpy as np import cv2 import matplotlib.pyplot as plt # Carrega la imatge després en escala de grisos image = cv2.imread ('elephant.jpg') gray = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) # Mostra la imatge original cv2.imshow (' Imatge d'entrada ', imatge) cv2.waitKey (0) #defining the parameters, size cell and size size # hxw in pixels cell_size = (8, 8) # hxw in cells cell_size = (2, 2) # number of orientation bins nbins = 9 # Utilitzant el descriptor HOG d'OpenCV # winSize és la mida de la imatge retallada a un múltiple de la mida de la cel·la 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 una forma de matriu numpy que utilitzem per crear funcions de porc n_cells = (gray.shape // cell_size, gray.shape // cell_size) # Primer indexem els blocs per files. # hog_feats ara conté les amplituds del gradient per a cada direcció, # per a cada cel·la del seu grup per a cada grup. La indexació es fa per files i per columnes. hog_feats = hog.compute (gris).reshape (n_cells - block_size + 1, n_cells - block_size + 1 , block_size, block_size, nbins).transpose ((1, 0, 2, 3, 4)) # Creeu la nostra matriu de gradients amb dimensions nbin per emmagatzemar orientacions de gradient gradients = np.zeros ((n_cells, n_cells, nbins)) # Crea una matriu de dimensions 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 mitjans de 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 ('igual', ajustable = 'caixa') plt.colorbar () plt.show () cv2.destroyAllWindows ()
La imatge mostra com es representa la imatge d’entrada com a representació HOG.
Classificadors en cascada HAAR
Com s’ha comentat anteriorment, podem extreure funcions d’una imatge i utilitzar-les per classificar o detectar objectes.
Què són els classificadors en cascada HAAR?
Un mètode de detecció d'objectes que introdueix les característiques de Haar en una sèrie de classificadors (en cascada) per identificar objectes en una imatge. Estan entrenats per identificar un tipus d’objecte, però podem utilitzar-ne diversos en paral·lel, per exemple, detectant ulls i cares junts.
Classificadors HAAR explicats:
Els classificadors HAAR s’entrenen utilitzant moltes imatges positives (és a dir, imatges amb l’objecte present) i
imatges negatives (és a dir, imatges sense l’objecte present).
Un cop tenim aquestes imatges, extraiem les característiques mitjançant finestres corredisses de blocs rectangulars. Aquestes característiques (característiques HAAR) tenen un valor únic i es calculen restant la suma de les intensitats de píxels sota els rectangles blancs dels rectangles negres.
Tot i això, es tracta d’un nombre ridícul de càlculs, fins i tot per a una finestra base de 24 x 24 píxels (180.000 funcions generades).
Així doncs, els investigadors van idear un mètode anomenat Integral Images que el va calcular amb quatre referències de matriu. Tot i això, encara tenien 180.000 funcions i la majoria no van afegir cap valor real.
A continuació, es va utilitzar Boosting per determinar les funcions més informatives, amb AdaBoost de Freund & Schapire i va trobar les característiques més informatives a la imatge. L’augment és el procés mitjançant el qual utilitzem classificadors febles per construir classificadors forts, simplement assignant penalitzacions més pesades a classificacions incorrectes. Reducció de les 180.000 funcions a 6000, que encara són força funcions.
En aquestes 6000 funcions, algunes seran més informatives que d’altres. Per tant, si utilitzem les funcions més informatives per comprovar primer si la regió pot tenir un rostre (els falsos positius no seran cap problema). Fer-ho elimina la necessitat de calcular totes les 6000 funcions alhora. Aquest concepte s’anomena Cascada de classificadors: per a la detecció de cares, el mètode Viola Jones utilitzava 38 etapes.
Detecció de cara i ulls
Per tant, després d’haver obtingut alguns coneixements teòrics sobre les cascades HAAR, finalment ho implementarem, de manera que, per deixar les coses ben clares, trencarem les lliçons per parts, primer detectaríem la cara frontal i després passarem a detectar la cara frontal amb ulls i, finalment, faríem la detecció en directe de cara i ulls a través de la càmera web.
Per això, utilitzarem classificadors pre-entrenats que han estat proporcionats per OpenCV com a fitxers.xml, xml significa llenguatge de marques extensible, aquest llenguatge s’utilitza per emmagatzemar una gran quantitat de dades, fins i tot podeu crear una base de dades.
Podeu accedir a aquests classificadors en aquest enllaç .
Detecció de cares
Intentem la detecció de cares frontals, aquí podeu accedir a la cascada del detector de cares frontals. Només cal extreure el fitxer zip per obtenir el fitxer XML.
NumPy importació com p importació CV2 # Assenyalem funció CascadeClassifier de OpenCV a on el nostre s'emmagatzema # classificador (format d'arxiu XML), recordeu que ha de mantenir el codi i classificador a la mateixa carpeta face_cascade = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') # Càrrega la nostra imatge la converteix a escala de grisos image = cv2.imread ('Trump.jpg') gris = cv2.cvtColor (imatge, cv2.COLOR_BGR2GRAY) # El nostre classificador retorna el ROI de la cara detectada com a tupla # Emmagatzema la part superior esquerra coordenades i la coordenades inferior dreta # torna la llista de llistes, que són la ubicació de les diferents cares detectades. faces = face_cascade.detectMultiScale (gris, 1,3, 5) # Quan no es detecta cap cara, torna el classificador de cara i buida la tupla si les cares és (): print ("No s'han trobat cares") # Iterem a través de la nostra matriu de cares i dibuixem un rectangle # sobre cada cara en cares per a (x, y, w, h) a les cares: cv2.rectangle (imatge, (x, y), (x + w, y + h), (127,0.255), 2) cv2.imshow ('Detecció de rostres', imatge) cv2.waitKey (0) cv2.destroyAllWindows ()
Ara combinem la detecció d'ulls i de cara junts, ja que podeu tenir accés a la cascada del detector d'ulls al mateix fitxer 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 (gris, 1,3, 5) # Quan no es detecta cap cara, torna_classifier i buida la tupla si les cares són (): print ("No es troba cap cara") per a (x, y, w, h) a les cares: cv2.rectangle (img, (x, y), (x + w, y + h), (127,0,255), 2) cv2.imshow ('img', img) roi_gray = gris 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)
El que aquest codi és el mateix tant com que el codi per a la detecció de rostres, però cascades ull aquí que hem afegit i el mètode per a la detecció d'ells, com es pot veure que hem triat l'escala de grisos versió de la cara com el paràmetre per al detectMultiScale de els ulls, cosa que ens porta a la reducció del càlcul, ja que només detectarem els ulls només en aquesta àrea.
Detecció de cares i ulls en viu
Per tant, fins ara hem fet la detecció de cara i ulls, ara implementem el mateix amb la transmissió de vídeo en directe des de la càmera web. En això farem la mateixa detecció de cara i ulls, però aquesta vegada ho farem per a la transmissió en directe de la càmera web. A la majoria de l'aplicació, trobareu la cara ressaltada amb un quadre al voltant, però aquí hem fet alguna cosa diferent que trobareu que la vostra cara es retallaria i els ulls només s'identificarien en això.
Per tant, aquí importem tant el classificador de cara com d’ulls, i hem definit una funció per fer tot el processament per a la detecció de cara i ulls. I després d'això, es va iniciar el flux de càmera web i va trucar a la funció de detector de cares per detectar la cara i els ulls. El paràmetre que definim dins de la funció del detector de cares són les imatges contínues de la transmissió de càmeres web en directe
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): # Converteix la imatge en gris gris (img, cv2.COLOR_BGR2GRAY) faces = face_classifier.detectMultiScale (gris, 1,3, 5) si les cares són (): torneu img per (x, y, w, h) en cares: 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 = gris roi_color = img eyes = eye_classifier.detectMultiScale (roi_gray) per a (ex, ey, ew, eh) als ulls: 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) mentre que True: ret, frame = cap.read () cv2.imshow ('Our Face Extractor', face_detector (frame)) if cv2.waitKey (1) == 13: # 13 is the Enter Key break cap.release () cv2.destroyAllWindows ()
Tuning de classificadors de cascades
Els paràmetres definits a detectMultiScale diferents de la imatge d’entrada tenen la següent importància
el nostre classificador. detectMultiScale (imatge d'entrada, factor d'escala, veïns mínims)
- Factor d’escala Especifica quant reduïm la mida de la imatge cada vegada que escalem. Per exemple, en la detecció de cares normalment fem servir 1.3. Això vol dir que reduïm la imatge un 30% cada vegada que s’escala. Els valors més petits, com l’1,05, trigaran més a calcular-se, però augmentaran la velocitat de detecció.
- Veïns mínims Especifica el nombre de veïns que hauria de tenir cada finestra potencial per considerar-la una detecció positiva. Normalment s'estableix entre 3 i 6. Actua com a paràmetre de sensibilitat; els valors baixos de vegades detecten múltiples cares sobre una sola cara. Els valors elevats garantiran menys falsos positius, però és possible que falti algunes cares.
Detecció de vehicles i vianants en vídeos
Ara detectarem vianants i cotxes en vídeos mitjançant les cascades HAAR, però en cas que no es carregui cap vídeo i el codi es compili sense cap error, heu de seguir els passos següents:
Si no es carrega cap vídeo després d'executar el codi, potser haureu de copiar el nostre opencv_ffmpeg.dl des de : opencv \ sources \ 3rdparty \ ffmpeg per enganxar-lo on hi hagi instal·lat el vostre python, per exemple, C: \ Anaconda2
Una vegada que es copia haurà de canviar el nom de l'arxiu d'acord amb la versió de OpenCV que ets using.eg si està utilitzant OpenCV 2.4.13 canviï el nom de l'arxiu com: opencv_ffmpeg2413_64.dll o opencv_ffmpeg2413.dll (si està amb una màquina X86) opencv_ffmpeg310_64.dll o opencv_ffmpeg310.dll (si feu servir una màquina X86)
Per esbrinar on està instal·lat python.exe, només cal que executeu aquestes dues línies de codi, imprimiria la ubicació on s’instal·la Python.
importar sys print (sys.executable)
Ara bé, si heu fet aquests passos amb èxit, anem al codi de detecció de vianants, Podeu obtenir la cascada per a la detecció de vianants i des del fitxer zip adjunt aquí.
import cv2 import numpy as np # Crea el nostre classificador corporal body_classifier = cv2.CascadeClassifier ('haarcascade_fullbody.xml') # Inicia la captura de vídeo per al fitxer de vídeo, aquí estem fent servir el fitxer de vídeo en què es detectarien els vianants cap = cv2.VideoCapture ('walking.avi') # Bucle una vegada que el vídeo s'ha carregat correctament mentre cap.isOpened (): # Llegint cada fotograma de la ret de vídeo , frame = cap.read () # aquí estem canviant la mida del fotograma a la meitat de la seva mida, estem fent per accelerar la classificació #, ja que les imatges més grans tenen moltes més finestres per lliscar, de manera que en general reduïm la resolució #de vídeo a la meitat és el que indica 0,5, i també estem utilitzant un mètode d’interpolació més ràpid que és #interlinear frame = cv2.resize (frame, None, fx = 0,5, fy = 0,5, interpolation = cv2.INTER_LINEAR) gray = cv2. cvtColor (marc, cv2.COLOR_BGR2GRAY) # Pass marc als nostres classificador cos cossos = body_classifier.detectMultiScale (gris, 1,2, 3) # extracte de quadres delimitadors els dels òrgans identificats per (x, y, w, h) en els òrgans: CV2. rectangle (marc, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow ('vianants', marc) si cv2.waitKey (1) == 13: # 13 és la tecla Retorn ruptura cap.release () cv2.destroyAllWindows ()
Després de detectar amb èxit el vianant al vídeo, anem al codi per a la detecció de cotxes. Des d'aquí podeu obtenir la cascada per a la detecció de vianants.
import cv2 import time import numpy as np # Crea el nostre classificador corporal car_classifier = cv2.CascadeClassifier ('haarcascade_car.xml') # Iniciar la captura de vídeo per al fitxer de vídeo cap = cv2.VideoCapture ('cars.avi') # Bucle una vegada que el vídeo es realitza correctament carregat mentre es cap.isOpened (): time.sleep (.05) # Llegir el primer retret de fotogrames, frame = cap.read () gris = cv2.cvtColor (trama, cv2.COLOR_BGR2GRAY) # Passar el marc al nostre classificador de vehicles cars = car_classifier.detectMultiScale (gris, 1,4, 2) # Extreure quadres de delimitació per a qualsevol cos identificat per (x, y, w, h) als vehicles: cv2.rectangle (frame, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow ('Cars', frame) if cv2.waitKey (1) == 13: # 13 is the Enter Key break cap.release () cv2.destroyAllWindows ()
Heu notat que hem afegit time.sleep (.05) , és només un retard en la velocitat de trames , de manera que podeu confirmar que tots els cotxes estan correctament identificats o bé podeu eliminar-lo fàcilment afegint-hi una etiqueta de comentari.
Aquest article es remet a Master Computer Vision ™ OpenCV4 a Python amb el curs Deep Learning sobre Udemy, creat per Rajeev Ratan, subscriviu-lo per obtenir més informació sobre Computer Vision i Python.