- Detekcia objektov pomocou SIFT
- Detekcia objektov pomocou ORB
- Histogram orientovaných gradientov (HOG)
- Histogram orientovaných gradientov (HOG), krok za krokom:
- Kaskádové klasifikátory HAAR
- Detekcia tváre a očí
- Živá detekcia tváre a očí
- Ladenie kaskádových klasifikátorov
- Detekcia automobilov a chodcov vo videách
Začali sme inštaláciou pythonu OpenCV na Windows a doteraz sme vykonali základné spracovanie obrazu, segmentáciu obrazu a detekciu objektov pomocou Pythonu, ktoré sú popísané v nasledujúcich výučbách:
- Začíname s Python OpenCV: Inštalácia a základné spracovanie obrazu
- Manipulácie s obrázkami v Pythone OpenCV (1. časť)
- Manipulácie s obrázkami v OpenCV (časť 2)
- Segmentácia obrazu pomocou OpenCV - extrakcia konkrétnych oblastí obrázka
Dozvedeli sme sa tiež o rôznych metódach a algoritmoch detekcie objektov, kde boli identifikované niektoré kľúčové body pre každý objekt pomocou rôznych algoritmov. V tomto výučbe použijeme tieto algoritmy na detekciu skutočných objektov, tu by sme na detekciu použili SIFT a ORB.
Detekcia objektov pomocou SIFT
Tu sa detekcia objektu uskutoční pomocou živého toku webovej kamery, takže ak rozpozná objekt, spomenul by nájdený objekt. V kóde hrá hlavnú časť funkcia, ktorá sa nazýva SIFT detektor, väčšina spracovania sa vykonáva práve touto funkciou.
A v druhej polovici kódu začíname otvorením streamu webovej kamery, potom načítame šablónu obrázka, tj. Referenčný obrázok, ktorý program v skutočnosti pozerá cez prúd webovej kamery.
Ďalej sme priebežne zachytenie snímok z webkamery prúdu s pomocou nekonečného zatiaľ čo slučky, a potom dôjde k zachyteniu zodpovedajúce výšku a šírku webkamery rámu, a po potom definovať parametre regiónu krabice (ROI) záujmu, v ktorých náš objekt zapadne do zodpovedajúcej výšky a šírky rámu webovej kamery. Potom nakreslíme obdĺžnik z parametrov ROI, ktoré sme definovali vyššie. Potom nakoniec obdĺžnik orezajte a vložte do časti kódu detektora SWIFT.
Teraz má detektor SIFT v zásade dva vstupy, jeden je orezaný obrázok a druhý je šablóna obrázka, ktorú sme predtým definovali, a potom nám poskytne nejaké zhody, takže zhody sú v zásade počtom objektov alebo kľúčových bodov, ktoré sú podobné orezanému obrázku a cieľový obrázok. Potom definujeme prahovú hodnotu pre zhody, ak je hodnota zhody väčšia ako prahová hodnota, vložíme obrázok nájdený na našu obrazovku so zelenou farbou obdĺžnika ROI.
Teraz sa vráťme späť k hlavnej časti kódu, funkcii, ktorá sa nazýva SIFT detektor, vstup sa berie ako dva obrázky, jeden je obraz, kde hľadá objekt, a druhý je objekt, ktorý sa snažíme nájsť. do (šablóna obrázka). Potom nastavte prvý obrázok v šedej škále a šablónu obrázka definujte ako druhý obrázok. Potom vytvoríme objekt detektora SIFT a spustíme funkciu detekcie a výpočtu OpenCV SIFT, aby sme mohli zistiť kľúčové body a vypočítať deskriptory, deskriptory sú v podstate vektory, ktoré ukladajú informácie o kľúčových bodoch, a je skutočne dôležité, keď robíme porovnávanie medzi deskriptormi obrázkov.
A potom definujeme porovnávač založený na FLANN, nebudeme sa za tým zaoberať matematickou teóriou párovania, ale môžete si o tom ľahko vygoogliť. Najskôr definujte index kdtree na nulu a potom nastavíme parametre indexu a vyhľadávania vo formáte slovníka, iba definujeme algoritmus, ktorý použijeme, ktorým je KDTREE, a počet stromov, ktoré budeme používať, tým viac stromov používame to tým komplikovanejšie a pomalšie. A vo vyhľadávacom parametri definujte počet kontrol, čo je v podstate počet zhôd, ktoré sa majú dokončiť.
A potom vytvorte náš objekt porovnávača založený na FLANN načítaním parametra, ktorý sme predtým definovali, čo sú parametre indexu a parametre vyhľadávania, a na základe toho vytvorte náš porovnávač založený na FLANN, ktorý je porovnávačom KNN, kde KNN sú K-najbližší susedia, v podstate je to spôsob, kde hľadáme najbližšie zhody a deskriptory a urobíme párovanie s inicializačnou konštantou k. Teraz tento porovnávač založený na FLANN vracia počet zápasov, ktoré dostaneme.
Zhoda založená na FLANN je len približná hodnota, aby sme zvýšili presnosť porovnávača založeného na FLANN, vykonáme test pomeru Loweho a čo urobí, je vyhľadanie zhôd z porovnávača založeného na knn flann a definovanie niektorých parametrov matice, čo je vzdialenosť tu, pre ktoré je vzdialenosť funkciou numpy, a akonáhle splní kritériá, pripojí zhody k dobrým a vráti nájdené dobré zhody, a tak živý videostream povie počet nájdených zhody v rohu obrazovky.
Teraz sa pozrime na kód vyššie uvedeného popisu:
import cv2 import numpy ako np def sift_detector (new_image, image_template): # Funkcia, ktorá porovnáva vstupný obrázok so šablónou # Potom vráti počet SIFT zápasov medzi nimi image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) image2 = image_template # Vytvoriť Objekt detektora SIFT #sift = cv2.SIFT () sift = cv2.xfeatures2d.SIFT_create () # Získajte kľúčové body a deskriptory pomocou SIFT keypoints_1, descriptors_1 = sift.detectAndCompute (image1, None) keypoints_2, descriptors_2 = sift.detect Žiadne) # Definujte parametre pre náš Flann Matcher FLANN_INDEX_KDTREE = 0 index_params = dict (algoritmus = FLANN_INDEX_KDTREE, stromy = 3) search_params = dict (kontroly = 100) # Vytvoriť objekt Flann dohadzovač Flann = cv2.FlannBasedMatcher (index_params, search_params) # Získanie zápasoch za použitia k-najbližších susedov Metóda # Výsledné, matchs 'je počet podobných zápasoch nájdené v oboch obrazov zápasov = flann.knnMatch (descriptors_1, descriptors_2, k = 2) # Uložte dobré zápasy pomocou testu pomeru Loweho good_matches = pre m, n v zápasoch: ak m.distance <0,7 * n.distance: good_matches.append (m) return len (good_matches) cap = cv2.VideoCapture (0) # Načítajte našu šablónu obrázka, toto je náš referenčný obrázok image_template = cv2.imread ('phone.jpg', 0) zatiaľ čo True: # Získajte obrázky webkamery ret, frame = cap.read () # Získať výšku a šírku výšky rámu webovej kamery , width = frame.shape # Definovať ROI Box Rozmery 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)) # Nakreslite obdĺžnikové okno pre našu oblasť záujmu cv2.rectangle (frame, (top_left_x, top_left_y)), (bottom_right_x, bottom_right_y), 255, 3) # Orezávacie okno pozorovania, ktoré sme definovali vyššie, orezané = rám # Flip orientácia rámca vodorovne rám = cv2.flip (rám, 1) # Získať počet SIFT zápasov = sift_detector (orezané, image_template) # Zobraziť stavový reťazec zobrazujúci aktuálne číslo. zápasov cv2.putText (frame, str (match), (450,450), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 1) # Náš limit na označenie objektu deteciton # Používame 10, pretože detektor SIFT vracia málo falošných správ prahová hodnota = 10 # Ak zhody prekročia našu prahovú hodnotu, bol objekt zistený, ak zhody> prahová hodnota: cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (rámec, 'Object Found', (50,50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow ('Object Detector using SIFT', frame), ak cv2.waitKey (1) == 13: # 13 je Enter Key break cap.release () cv2.destroyAllWindows ()
Detekcia objektov pomocou ORB
Detekcia objektov pomocou SIFT je vcelku v pohode a presná, pretože generuje oveľa presný počet zhôd na základe kľúčových bodov, nech je akýkoľvek patentovaný, a preto je ťažké ho použiť na komerčné účely, iným východiskom je algoritmus ORB. na detekciu objektu.
Podobne ako pri metóde detekcie objektov pomocou SIFT, v ktorej sme program rozdelili na dve časti, bude sa postupovať rovnako aj tu.
Najskôr definujeme funkciu ORB_detector, ktorá prijíma dva vstupy, jeden je obraz živého vysielania prichádzajúci z webovej kamery a druhý je šablóna obrazu, na základe ktorej budeme porovnávať náš obrázok. Potom obraz našej webovej kamery upravíme v šedých odtieňoch a potom inicializujeme náš detektor ORB, ktorý tu nastavíme na 1 000 kľúčových bodov a parametre mierky 1,2. s týmito parametrami sa môžete ľahko pohrať, potom zistiť kľúčové body (kp) a deskriptory (des) obidvoch obrázkov a druhý parameter, ktorý definujeme vo funkcii detectANDCompute, je ŽIADNY , žiada použitie masky obrazu alebo nie a my to tu popierame.
Potom prejdite na detektor, ktorý sme predtým používali pomocou porovnávača založeného na FLANN, ale tu budeme používať BFMatcher a vo vnútri BFMatcher definujeme dva parametre, jeden je NORM_HAMMING a druhý je krížová kontrola, ktorej hodnota je PRAVDA.
Potom vypočítajte zhody zhody medzi týmito dvoma obrázkami pomocou deskriptorov definovaných vyššie, ktoré vo všetkých vráti počet zhody, pretože tieto zhody nie sú približné, a preto nie je potrebné robiť test pomeru Loweho, namiesto toho zoraďujeme zhody podľa vzdialenosti, najmenšia vzdialenosť je lepšia (tu znamená vzdialenosť medzi bodmi) a na konci pomocou funkcie dĺžky vrátime počet zápasov.
A v hlavnej funkcii nastavíme prahovú hodnotu na oveľa vyššiu hodnotu, pretože detektor guľôčok generuje veľa šumu.
Teraz sa pozrime na kód na detekciu na báze ORB
import cv2 import numpy ako np def ORB_detector (new_image, image_template): # Funkcia, ktorá porovnáva vstupný obrázok so šablónou # Potom vráti počet zhodných ORB medzi nimi image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) # Vytvorte detektor ORB pomocou 1 000 kľúčových bodov s faktorom zmeny veľkosti pyramídy 1,2 orb = cv2.ORB_create (1000, 1,2) # Zistiť kľúčové body pôvodného obrázka (kp1, des1) = orb.detectAndCompute (obrázok1, Žiadne) # Zistiť kľúčové body otočeného obrázka (kp2, des2) = orb.detectAndCompute (image_template, None) # Vytvoriť porovnávač # Upozorňujeme, že už nepoužívame Flannbased zodpovedajúce bf = cv2.BFMatcher (cv2.NORM_HAMMING, crossCheck = True) # Zhodujú sa zápasy = bf.match (des1, des2) # Zoraďte zápasy podľa vzdialenosti. Najmenej vzdialenosti # sú lepšie zhody = zoradené (zhody, kľúč = lambda val: val.distance) návrat len (zhody) cap = cv2.VideoCapture (0) # Načítajte našu šablónu obrázka, toto je náš referenčný obrázok image_template = cv2.imread ('phone.jpg', 0) # image_template = cv2.imread ('images / kitkat.jpg', 0) while True: # Získať obrázky z webovej kamery ret, frame = cap.read () # Získať výšku a šírku výšky rámu z webovej kamery , width = frame.shape # Definujte rozmery poľa ROI (všimnite si, že niektoré z týchto vecí by mali byť mimo slučky) top_left_x = int (width / 3) top_left_y = int ((výška / 2) + (výška / 4)) bottom_right_x = int ((šírka / 3) * 2) bottom_right_y = int ((výška / 2) - (výška / 4)) # Nakreslite obdĺžnikové okno pre našu oblasť záujmu cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) # Orezávacie okno pozorovania, ktoré sme definovali vyššie, orezané = rám # Flip orientácia rámu horizontálne rám = cv2.flip (rám, 1) # Získať počet zhodov ORB = ORB_detector (orezaný, image_template) # Zobraziť stavový reťazec zobrazujúci aktuálne č. zápasov output_string = "Zhody =" + str (zhody) cv2.putText (rámec, output_string, (50 450), cv2.FONT_HERSHEY_COMPLEX, 2, (250 0 150), 2) # Naša hranica na indikáciu detekcie objektu # Pre nové obrázky alebo svetelné podmienky budete možno musieť trochu experimentovať # Poznámka: Detektor ORB na získanie najlepších 1 000 zhôd, 350 je v podstate minimálna hranica zhody 35% = 250 # Ak zápasy prekročia prahová hodnota, potom bol objekt zistený, ak sa zhoduje> prahová hodnota: cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (rámec, „Objekt nájdený“, (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow ('Object Detector using ORB', frame), ak cv2.waitKey (1) == 13: # 13 je čiapka Enter Key break .release () cv2.destroyAllWindows ()
Histogram orientovaných gradientov (HOG)
Teraz si povieme niečo o inom deskriptore, ktorým je histogram orientovaných gradientov (HOG).
HOG sú do značnej miery cool a užitočné deskriptory a sú široko a úspešne používané na detekciu objektov, ako už bolo vidieť predtým, deskriptory obrázkov ako SIFT a ORB, kde musíme vypočítať kľúčové body a potom musíme z týchto kľúčových bodov vypočítať deskriptory, HOG to robí inak. To predstavuje objekty ako jediné funkcie vektora, na rozdiel od množiny príznakových vektorov, kde každý z nich predstavuje segment obrazu. To znamená, že pre celý obrázok máme jedinú vektorovú funkciu.
Vypočíta sa to detektorom posuvného okna nad obrazom, kde sa pre každú pozíciu počíta deskriptor HOG. Potom sa každá pozícia skombinuje do jedného vektora funkcií.
Rovnako ako SIFT sa mierka obrázka upravuje pyramídou.
Predtým sme používali porovnávače ako FLANN a BFMatcher, ale HOG to robia inak pomocou klasifikátorov SVM (support vector machine), kde sa každý vypočítaný deskriptor HOG podáva do klasifikátora SVM, aby sa zistilo, či bol objekt nájdený alebo nie.
Tu je odkaz na skvelý príspevok od Dalala & Triggsa o používaní HOG na detekciu ľudí:
Histogram orientovaných gradientov (HOG), krok za krokom:
Pochopenie HOG môže byť pomerne zložité, ale tu sa budeme zaoberať iba HOG teóriou bez toho, aby sme sa hlbšie zaoberali matematikou, ktorá s ňou súvisí.
Poďme teda urobiť tento obrázok, ktorý je trochu pixelovaný a v hornom rohu je pole 8x8 pixelov, takže v tomto poli vypočítame gradientový vektor alebo orientáciu okrajov pri každom pixeli. To znamená, že v tomto poli vypočítame vektor gradientu obrazu pixelov vo vnútri poľa (sú to akýsi smer alebo tok samotnej intenzity obrazu) a vygeneruje sa 64 (8 x 8) vektorov gradientu, ktoré sa potom zobrazia ako histogram. Predstavte si teda histogram, ktorý predstavuje každý gradientový vektor. Keby teda všetky body alebo intenzity klamali jedným smerom, histogram pre tento smer povedzme 45 stupňov, histogram by mal vrchol pri 45 stupňoch.
To, čo teraz robíme, je rozdelenie každej bunky do uhlových košov, kde každý kôš zodpovedá smeru gradientu (napr. X, y). V dokumentoch Dalal a Triggs použili 9 košov 0 - 180 ° (po 20 ° každý kôš). Toto efektívne redukuje 64 vektorov na iba 9 hodnôt. To, čo sme urobili, je teda zmenšenie veľkosti, ale uchovali sa všetky kľúčové informácie, ktoré sú potrebné.
Ďalším krokom pri výpočte prasaťa je normalizácia, normalizujeme gradienty, aby sa zabezpečila invariantnosť so zmenami osvetlenia, tj. Jas a kontrast.
Na tomto obrázku sú hodnoty intenzity zobrazené vo štvorci podľa príslušného smeru a všetky majú medzi sebou rozdiel 50
∆ H = 50, ∆ v = 50; │∆│ = √50 2 +50 = 70,72, 70,72 / 100 = 0,707
Vektory vydelíme gradientovými veľkosťami, ktoré dostaneme 0,707 za všetky, to je normalizácia.
Podobne, ak zmeníme intenzitu alebo zmeníme kontrast, dostaneme nižšie uvedené hodnoty.
∆ 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
Normalizácia neprebieha na bunkovej úrovni, ale na blokovej úrovni, takže tu bloky tvoria v podstate skupinu 4 buniek, čo zohľadňuje susedné bloky, takže sa normalizuje, pričom sa zohľadňujú väčšie segmenty obrazu.
Teraz sa pozrime na kód
import numpy ako np import cv2 import matplotlib.pyplot ako plt # Načítať obrázok a potom odtiene šedej image = cv2.imread ('elephant.jpg') šedá = cv2.cvtColor (obrázok, cv2.COLOR_BGR2GRAY) # Zobraziť pôvodný obrázok cv2.imshow (' Vstupný obrázok ', obrázok) cv2.waitKey (0) # definovanie parametrov, veľkosť bunky a veľkosť bloku # hxw v pixeloch cell_size = (8, 8) # hxw v bunkách block_size = (2, 2) # počet orientačných košov nbins = 9 # Pomocou deskriptoru HOG OpenCV # winSize je veľkosť obrázku orezaná na násobok veľkosti bunky hog = cv2.HOGDescriptor (_winSize = (gray.shape // cell_size * cell_size, grey.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) # Vytvoríme použitie tvaru poľa na vytvorenie hog_features n_cells = (grey.shape // cell_size, grey.shape // cell_size) # Najskôr indexujeme bloky podľa riadkov. # hog_feats teraz obsahuje amplitúdy gradientu pre každý smer, # pre každú bunku jeho skupiny pre každú skupinu. Indexovanie je podľa riadkov a stĺpcov. hog_feats = hog.compute (grey).reshape (n_cells - block_size + 1, n_cells - block_size + 1, block_size, block_size, nbins).transpose ((1, 0, 2, 3, 4)) # Vytvorte naše pole prechodov s rozmermi nbin na ukladanie prechodových orientácií prechody = np.zeros ((n_cells, n_cells, nbins)) # Vytvorte pole rozmerov cell_count = np.full ((n_cells, n_cells, 1), 0, dtype = int) # Normalizácia bloku pre off_y v rozsahu (block_size): pre off_x v rozsahu (block_size): prechody - 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 # Priemerné gradienty gradientov / = cell_count # Plot HOG pomocou Matplotlib # uhol je 360 / nbins * smer color_bins = 5 plt.pcolor (gradienty) plt.gca (). invert_yaxis () plt.gca (). set_aspect ('rovnaké', nastaviteľné = 'krabica') plt.colorbar () plt.show () cv2.destroyAllWindows ()
Obrázok ukazuje, ako je vstupný obrázok reprezentovaný ako reprezentácia HOG.
Kaskádové klasifikátory HAAR
Ako už bolo uvedené, môžeme z obrázka extrahovať prvky a použiť ich na klasifikáciu alebo detekciu objektov.
Čo sú kaskádové klasifikátory HAAR?
Metóda detekcie objektov, ktorá vkladá prvky Haar do série klasifikátorov (kaskáda) na identifikáciu objektov v obraze. Sú vyškolení na identifikáciu jedného typu objektu, ale môžeme ich použiť niekoľko paralelne, napr. Spoločné detekovanie očí a tvárí.
Vysvetlenie klasifikátorov HAAR:
Klasifikátory HAAR sú trénované pomocou mnohých pozitívnych obrázkov (tj. Obrázkov s prítomným objektom) a
negatívnych obrazov (tj. Obrázkov bez prítomného objektu).
Keď tieto obrázky máme, extrahujeme ich pomocou posuvných okien obdĺžnikových blokov. Tieto prvky (prvky HAAR) majú jednu hodnotu a sú vypočítané odpočítaním súčtu intenzít pixelov pod bielymi obdĺžnikmi od čiernych obdĺžnikov.
Toto je však smiešny počet výpočtov, a to aj pre základné okno s rozmermi 24 x 24 pixelov (vygenerovaných 180 000 funkcií).
Vedci teda navrhli metódu nazvanú Integral Images, ktorá ju počíta so štyrmi odkazmi na pole. Stále však mali 180 000 funkcií a väčšina z nich nepriniesla žiadnu skutočnú hodnotu.
Posilnenie sa potom použilo na určenie najinformatívnejších funkcií pomocou programu AdaBoost od spoločnosti Freund & Schapire a našlo najinformatívnejšie prvky na obrázku. Posilňovanie je proces, pomocou ktorého používame slabé klasifikátory na vytváranie silných klasifikátorov, jednoducho tak, že priraďujeme prísnejšie vážené pokuty nesprávnym klasifikáciám. Zníženie počtu 180 000 funkcií na 6 000, čo je stále dosť veľa funkcií.
V týchto 6 000 funkciách budú niektoré viac informatívne ako iné. Takže ak sme najskôr použili najinformatívnejšie funkcie, aby sme skontrolovali, či región môže mať potenciálne tvár (falošné poplachy nebudú nič veľké). To eliminuje potrebu výpočtu všetkých 6000 funkcií naraz. Tento koncept sa nazýva Kaskáda klasifikátorov - na detekciu tváre použila metóda Violy Jonesovej 38 stupňov.
Detekcia tváre a očí
Takže po získaní teoretických vedomostí o HAAR kaskádach ich konečne implementujeme, aby bolo všetko jasné, rozbijeme lekcie po častiach, najskôr by sme detekovali čelnú tvár, potom sa presunieme k detekcii čelnej tváre s oči a nakoniec by sme naživo detekovali tvár a oči cez webovú kameru.
Preto na to použijeme vopred vyškolené klasifikátory, ktoré poskytuje OpenCV ako súbory.xml, xml znamená rozšíriteľný značkovací jazyk, tento jazyk sa používa na ukladanie veľkého množstva údajov, dokonca si na ňom môžete vytvoriť databázu.
Prístup k týmto klasifikátorom môžete získať na tomto odkaze .
Rozpoznávanie tváre
Pokúsme sa o detekciu čelnej tváre, tu môžete mať prístup pre kaskádu detektora čelnej tváre. Stačí rozbaliť zip súbor a získate XML súbor.
import numpy ako np import cv2 # Funkciu OpenCV CascadeClassifier ukazujeme na miesto, kde je uložený náš # klasifikátor (formát súboru XML), nezabudnite ponechať kód a klasifikátor v rovnakom priečinku face_cascade = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') # načítať náš obrázok ho potom prevedie na odtiene sivej image = cv2.imread ('Trump.jpg') šedá = cv2.cvtColor (obrázok, cv2.COLOR_BGR2GRAY) # Náš klasifikátor vráti ROI detekovanej tváre ako n - ticu # Uloží ľavý horný súradnica a súradnice vpravo dole # vráti zoznam zoznamov, ktoré obsahujú rôzne detekované tváre. Faces = face_cascade.detectMultiScale (sivá, 1,3, 5) # Keď nie sú zistené žiadne tváre, face_classifier sa vráti a vyprázdni n-ticu, ak je face is (): print ("Nenašli sa žiadne tváre") # Opakujeme naše pole tvárí a nakreslíme obdĺžnik # na každú tvár v plochách pre (x, y, w, h) v tvárach: cv2.rectangle (image, (x, y), (x + w, y + h), (127,0 255), 2) cv2.imshow ('Face Detection', image) cv2.waitKey (0) cv2.destroyAllWindows ()
Teraz poďme kombinovať detekciu tváre a očí dohromady, môžete mať prístup pre kaskádu detektora očí v rovnakom súbore zip.
importovať ako np import cv2 face_classifier = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') eye_classifier = cv2.CascadeClassifier ('haarcascade_eye.xml') img = cv2.imread ('Trump.jpg') šedá = cv2.cvtColo cv2.COLOR_BGR2GRAY) face = face_classifier.detectMultiScale (sivá, 1,3, 5) # Keď nie sú zistené žiadne tváre, face_classifier sa vráti a prázdnu n-ticu, ak je face is (): print ("No Face Found") pre (x, y, w, h)) v tvárach: cv2.rectangle (img, (x, y), (x + w, y + h), (127,0 255), 2) cv2.imshow ('img', img) roi_gray = šedá roi_color = img eyes = eye_classifier.detectMultiScale (roi_gray) cv2.waitKey (0) pre (ex, ey, ew, eh) v očiach: 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)
Takže tento kód je rovnaký, rovnako ako, že kód pre detekciu tváre, ale tu sme pridali oko kaskády a spôsob, ako ich odhaliť, ako môžete vidieť, sme zvolili Grey zmenšený verzii tváre ako parameter pre detectMultiScale pre oči, čo nás privádza k zníženiu výpočtu, pretože oči budeme detekovať iba v tejto oblasti.
Živá detekcia tváre a očí
Takže doteraz sme robili detekciu tváre a očí, implementujme to isté do priameho prenosu videa z webovej kamery. V tomto urobíme rovnakú detekciu tváre a očí, ale tentoraz to urobíme pre priamy prenos z webovej kamery. Vo väčšine aplikácií nájdete svoju tvár zvýraznenú rámčekom okolo nej, ale tu sme urobili niečo inak, že by ste našli svoju tvár orezanú a iba v tom by sa oči identifikovali.
Takže tu importujeme klasifikátor tváre aj očí a definovali sme funkciu pre celé spracovanie detekcie tváre a očí. A potom začal prúd webovej kamery a volal funkciu detektora tváre na zisťovanie tváre a očí. Parameter, ktorý definujeme vo vnútri funkcie detektora tváre, sú nepretržité obrázky zo živého prúdu webovej kamery
import cv2 import numpy ako np face_classifier = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') eye_classifier = cv2.CascadeClassifier ('haarcascade_eye.xml') def face_detector (img, veľkosť = 0,5): # Konvertovať obrázok na sivú stupnicu (img, cv2.COLOR_BGR2GRAY) Faces = face_classifier.detectMultiScale (sivá, 1,3, 5), ak Faces je (): Vrátiť img for (x, y, w, h) v plochách: x = x - 50 w = w + 50 y = y - 50 h = h + 50 cv2. obdĺžnik (img, (x, y), (x + w, y + h), (255,0,0), 2) roi_gray = šedá roi_color = img eyes = eye_classifier.detectMultiScale (roi_gray) pre (ex, ey, ew, eh) v očiach: cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (0,0,255), 2) roi_color = cv2.flip (roi_color, 1) návrat roi_color cap = cv2.VideoCapture (0) while True: ret, frame = cap.read () cv2.imshow ('Our Face Extractor', face_detector (frame)) if cv2.waitKey (1) == 13: # 13 je Enter Key break cap.release () cv2.destroyAllWindows ()
Ladenie kaskádových klasifikátorov
Parametre definované vo vnútri detectMultiScale iné ako vstupný obrázok majú nasledujúci význam
náš klasifikátor. detectMultiScale (vstupný obrázok, faktor mierky, minimálni susedia)
- Scale Factor Určuje, o koľko zmenšíme veľkosť obrázka pri každom zmenšení. Napríklad pri detekcii tváre zvyčajne používame 1.3. To znamená, že zakaždým, keď je obrázok zmenšený, zmenšíme ho o 30%. Výpočet menších hodnôt, napríklad 1,05, bude trvať dlhšie, ale zvýši sa miera detekcie.
- Min Neighbors Určuje počet susedov, ktoré by malo mať každé potenciálne okno, aby sa mohlo považovať za pozitívnu detekciu. Zvyčajne sa nastavuje medzi 3. až 6. dňom. Funguje ako nastavenie citlivosti, nízke hodnoty niekedy zistia viacnásobné tváre na jednej tvári. Vysoké hodnoty zabezpečia menej falošných poplachov, niektoré tváre vám však môžu chýbať.
Detekcia automobilov a chodcov vo videách
Teraz vo videách detegujeme chodcov a autá pomocou kaskád HAAR, ale v prípade, že sa nenačíta žiadne video a kód sa nezkompiluje bez chyby, musíte postupovať podľa nasledujúcich krokov:
Ak sa po spustení kódu nenačíta žiadne video, možno budete musieť skopírovať náš opencv_ffmpeg.dl z : opencv \ sources \ 3rdparty \ ffmpeg a vložiť ho tam, kde je nainštalovaný váš python, napr. C: \ Anaconda2
Po skopírovaní budete musieť súbor premenovať podľa verzie OpenCV, ktorú používate. Napríklad ak používate OpenCV 2.4.13, potom súbor premenujte takto: opencv_ffmpeg2413_64.dll alebo opencv_ffmpeg2413.dll (ak používate pomocou stroja X86) opencv_ffmpeg310_64.dll alebo opencv_ffmpeg310.dll (ak používate stroj X86)
Ak chcete zistiť, kde je nainštalovaný súbor python.exe, stačí spustiť tieto dva riadky kódu. Vytlačí sa miesto, kde je nainštalovaný súbor python.
importovať tlač sys (sys.executable)
Ak ste tieto kroky vykonali úspešne, prejdime na kód na detekciu chodcov, Kaskádu na detekciu chodcov môžete mať tu a zo súboru zip tu pripojeného.
import cv2 import numpy ako np # Vytvorte náš klasifikátor tela body_classifier = cv2.CascadeClassifier ('haarcascade_fullbody.xml') # Spustite snímanie videa pre videosúbor, tu používame videosúbor, v ktorom by boli detekovaní chodci cap = cv2.VideoCapture ('walking.avi') # Slučka, keď sa video úspešne načíta, zatiaľ čo cap.isOpened (): # Čítanie jednotlivých snímok videa ret, frame = cap.read () # tu meníme veľkosť rámu na polovicu jeho veľkosti robíme pre urýchlenie klasifikácie #, pretože väčšie obrázky majú oveľa viac okien , ktoré sa dajú prekĺznuť , takže celkovo znižujeme rozlíšenie #of video o polovicu, to je to, čo 0,5 naznačuje, a tiež používame rýchlejšiu metódu interpolácie, ktorá je #interlinear frame = cv2.resize (frame, None, fx = 0,5, fy = 0,5, interpolation = cv2.INTER_LINEAR) grey = cv2. cvtColor (frame, cv2.COLOR_BGR2GRAY) # Prejdite rámec do nášho klasifikátora tiel body = body_classifier.detectMultiScale (šedá, 1,2, 3) # Extrahujte ohraničujúce rámce pre všetky telá identifikované pre (x, y, w, h) v telách: cv2. obdĺžnik (rám, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow ('Chodci, rám), ak cv2.waitKey (1) == 13: # 13 je Enter Key break cap.release () cv2.destroyAllWindows ()
Po úspešnej detekcii chodca vo videu prejdime na kód detekcie automobilov. Odtiaľto môžete mať kaskádu na detekciu chodcov.
import cv2 čas importu import numpy ako np # Vytvorte náš klasifikátor tela car_classifier = cv2.CascadeClassifier ('haarcascade_car.xml') # Spustiť zachytenie videa pre súbor videa cap = cv2.VideoCapture ('cars.avi') # Opakovať video po úspešnom dokončení načítané, zatiaľ čo cap.isOpened (): time.sleep (.05) # Prečítajte prvý ret ret, frame = cap.read () grey = cv2.cvtColor (frame, cv2.COLOR_BGR2GRAY) # Preneste rám do nášho klasifikátora automobilov cars = car_classifier.detectMultiScale (sivá, 1,4, 2) # Extrahujte ohraničujúce rámčeky pre všetky orgány identifikované pre (x, y, w, h) v automobiloch: cv2.rectangle (frame, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow ('Cars', frame) if cv2.waitKey (1) == 13: # 13 je Enter Key break cap.release () cv2.destroyAllWindows ()
Všimli ste si, že sme pridali time.sleep (.05) , ide len o oneskorenie snímkovej frekvencie, aby ste mohli potvrdiť, že všetky autá sú správne identifikované, alebo ho môžete ľahko odstrániť pridaním štítku komentára.
Tento článok je odkázaný z programu Master Computer Vision ™ OpenCV4 v Pythone s kurzom Deep Learning na Udemy, ktorý vytvoril Rajeev Ratan. Prihláste sa na jeho odber, aby ste sa dozvedeli viac o Computer Vision a Python.