Откриване на обекти от реалния живот с помощта на opencv - откриване на обекти в видео на живо

Започнахме с инсталирането на python OpenCV на Windows и досега направихме някои основни обработки на изображения, сегментиране на изображения и откриване на обекти с помощта на Python, които са описани в уроците по-долу:

Първи стъпки с Python OpenCV: Инсталация и основна обработка на изображения
Манипулации с изображения в Python OpenCV (част 1)
Манипулации с изображения в OpenCV (част 2)
Сегментиране на изображения с помощта на OpenCV - Извличане на специфични области на изображение

Също така научихме за различни методи и алгоритми за откриване на обекти, където някои ключови точки бяха идентифицирани за всеки обект, използвайки различни алгоритми. В този урок ще използваме тези алгоритми за откриване на обекти от реалния живот, тук ще използваме SIFT и ORB за откриване.

Откриване на обекти с помощта на SIFT

Тук откриването на обект ще се извършва с поток от уеб камера на живо, така че ако разпознае обекта, ще спомене objet found. В кода основната част се играе от функцията, която се нарича SIFT детектор, по-голямата част от обработката се извършва от тази функция.

И в другата половина на кода започваме с отварянето на потока от уеб камерата, след това зареждаме шаблона на изображението, т.е. референтното изображение, тоест програмата всъщност гледа през потока на уеб камерата.

След това непрекъснато улавяме изображенията от потока на уеб камерата с помощта на безкраен цикъл while и след това улавяме съответната височина и ширина на рамката на уеб камерата и след това дефинираме параметрите на полето на интересуващата област (ROI), в което нашият обект може да се побере, като вземе съответната височина и ширина на рамката на уеб камерата. И тогава изчертаваме правоъгълника от параметрите на ROI, които бяхме дефинирали по-горе. След това накрая изрежете правоъгълника и го подайте в SWIFT детекторната част на кода.

Сега SIFT детекторът основно има два входа, единият е изрязаното изображение, а другият е шаблонът на изображението, който предварително сме дефинирали и след това ни дава някои съвпадения, така че съвпаденията са основно броят на обектите или ключовите точки, които са сходни в изрязаното изображение и целевото изображение. След това дефинираме прагова стойност за съвпаденията, ако стойността на съвпаденията е по-голяма от прага, поставяме изображение, намерено на нашия екран със зелен цвят на ROI правоъгълник.

Сега нека се върнем към основната част на кода, функцията, която се нарича SIFT детектор, тя приема входа като две изображения едното е изображението, където търси обекта, а другото е обектът, който се опитваме да съпоставим до (шаблон на изображение). След това сиво скалирайте първото изображение и дефинирайте шаблона за изображение като второ изображение. След това създаваме обект на SIFT детектор и стартираме функцията за откриване и изчисляване на OpenCV SIFT, така че за откриване на ключовите точки и изчисляване на дескрипторите, дескрипторите са основно векторите, които съхраняват информацията за ключовите точки и е наистина важно, тъй като правим съвпадение между дескрипторите на изображенията.

И след това дефинирайте съвпадението, базирано на FLANN, ние не навлизаме в математическата теория за съвпадение зад него, но лесно можете да потърсите в Google за това. Първо, дефинирайте индекса kdtree на нула и след това задаваме параметрите на индекса и търсенето във формата на речника, просто дефинираме алгоритъма, който ще използваме, който е KDTREE, и броя на дърветата, които ще използваме, толкова повече дърво използваме колкото по-сложно става и по-бавно. И в параметъра за търсене дефинирайте броя на проверките, което всъщност е броят на съвпаденията, които ще завърши.

И след това създайте нашия обект за съвпадение, базиран на FLANN, като заредите параметъра, който предварително дефинирахме, които са параметри на индекса и параметри за търсене и въз основа на това създадем нашия съвпадение, базирано на FLANN, което е KNN съвпадение, където KNN е K-най-близките съседи, всъщност това е начин, при който търсим най-близки съвпадения и дескриптори и правим съвпадението с инициализираща константа k. Сега този базиран на FLANN съвпадение връща броя на съвпаденията, които получаваме.

Съпоставянето на базата на FLANN е само приблизително, така че за да се увеличи точността на съвпадението на базата на FLANN, ние провеждаме тест за съотношението на Lowe и това, което прави, е да търси съвпаденията от knn базиран на flann съвпадение и да дефинира някои матрични параметри, което е разстоянието тук, за което разстоянието е функция numpy и след като отговаря на критериите, добавете съответствията към добрите съвпадения и връща намерените добри съвпадения и така видеопотокът на живо казва броя на съвпаденията, намерени в ъгъла на екрана.

Сега нека разгледаме кода за горното описание:

import cv2 import numpy as np def sift_detector (new_image, image_template): # Функция, която сравнява входното изображение с шаблон # След това връща броя на SIFT съвпадения между тях image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GRAY) image2 = image_template # Create Обект на детектор SIFT #sift = cv2.SIFT () sift = cv2.xfeatures2d.SIFT_create () # Получаване на ключовите точки и дескриптори с помощта на SIFT keypoints_1, descriptors_1 = sift.detectAndCompute (image1, None) keypoints_2, descriptors_2 = sift.detete2 Няма) # Определете параметрите за нашия Flann Matcher FLANN_INDEX_KDTREE = 0 index_params = dict (алгоритъм = FLANN_INDEX_KDTREE, дървета = 3) search_params = dict (проверки = 100) # Създайте обекта Flann Matcher flann = cv2.FlannBasedMatcher (index_params, search_params) # Получаване на съвпадения с помощта на K-Neighbor Neighbor Method # резултатът "matchs" е броят на подобни съвпадения, намерени и в двете съвпадения на изображенията = flann.knnMatch (descriptors_1, descriptors_2, k = 2) # Съхранявайте добри съвпадения, използвайки теста на съотношението на Лоу good_matches = за m, n в съвпадения: ако m.distance <0.7 * n.distance: good_matches.append (m) return len (good_matches) cap = cv2.VideoCapture (0) # Заредете нашия шаблон за изображение, това е нашето референтно изображение image_template = cv2.imread ('phone.jpg', 0), докато True: # Вземете изображения от уеб камерата ret, frame = cap.read () # Вземете височина и ширина на височината на рамката на уеб камерата , width = frame.shape # Определете ROI Box Dimensions 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)) # Начертайте правоъгълен прозорец за интересуващата ни област cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) # Прозорец за наблюдение на изрязване, който дефинирахме по-горе изрязан = кадър # Обръщане на рамката ориентация хоризонтално frame = cv2.flip (кадър, 1) # Получете брой съвпадения на SIFT = sift_detector (изрязан, image_template) # Показване на низ за състояние, показващ текущия номер. на съвпадения cv2.putText (кадър, str (съвпадения), (450 450), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 1) # Нашият праг за индикация на обект детектиране # Използваме 10, тъй като SIFT детекторът връща малко фалшиви позиции prag = 10 # Ако съвпаденията надвишават нашия праг, тогава обектът е открит, ако съвпадения> праг: cv2.rectangle (рамка, (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 using SIFT', frame) if cv2.waitKey (1) == 13: # 13 е Enter Key break cap.release () cv2.destroyAllWindows ()

Откриване на обекти с помощта на ORB

Откриването на обекти с помощта на SIFT е доста готино и точно, тъй като генерира много точен брой съвпадения въз основа на ключови точки, но е патентовано и затруднява използването му за търговските приложения, другият изход за това е алгоритъмът ORB за откриване на обект.

Подобно на метода за откриване на обект чрез SIFT, при който разделихме програмата на две части, тук ще се следва същото.

Първо, дефинираме функцията ORB_detector, която взема два входа, единият е изображението на живо на живо, идващо от уеб камера, а другото е шаблонът на изображението, въз основа на който ще съпоставим изображението си. След това скалираме изображението на уеб камерата си в сиво и след това инициализираме нашия ORB детектор и го настройваме тук на 1000 ключови точки и параметри на мащабиране от 1.2. можете лесно да се заиграете с тези параметри, след това да откриете ключовите точки (kp) и дескрипторите (des) както за изображенията, така и за втория параметър, който дефинираме във функцията за откриване ANDCompute е НЯМА, той иска използването на маска на изображението или не и ние го отричаме тук.

След това преминете към детектора, преди използвахме съвпадение, базирано на FLANN, но тук ще използваме BFMatcher и вътре в BFMatcher дефинираме два параметъра, единият е NORM_HAMMING, а другият е crossCheck, чиято стойност е TRUE.

След това изчислете съвпаденията на съвпаденията между тези две изображения, като използвате дескрипторите, дефинирани по-горе, което във всички връща броя на съвпаденията, тъй като тези съвпадения не са апроксимация и следователно няма нужда да се прави съотношението на Лоу, вместо това ние сортираме мачовете въз основа на разстоянието, поне разстоянието повече съвпадение е по-добро (тук разстоянието означава разстояние между точките) и в края връщаме броя на съвпаденията, използвайки функцията за дължина.

И в основната функция задаваме прага на много по-висока стойност, тъй като детекторът на кълба генерира голяма част от шума.

Сега нека разгледаме кода за откриване на базата на ORB

import cv2 import numpy като np def ORB_detector (new_image, image_template): # Функция, която сравнява входното изображение с шаблон # След това връща броя на съвпаденията на ORB между тях image1 = cv2.cvtColor (new_image, cv2.COLOR_BGR2GREY) # Създаване на ORB детектор с 1000 ключови точки с пирамидален коефициент на мащабиране 1,2 orb = cv2.ORB_create (1000, 1.2) # Откриване на ключови точки на оригиналното изображение (kp1, des1) = orb.detectAndCompute (image1, None) # Откриване на ключови точки на завъртяно изображение (kp2, des2) = orb.detectAndCompute (image_template, None) # Създаване на съвпадение # Забележете, че вече не използваме Flannbased match bf = cv2.BFMatcher (cv2.NORM_HAMMING, crossCheck = True) # Направете съвпадение на съвпаденията = bf.match (des1, des2) # Сортирайте мачовете въз основа на разстоянието. Най-малкото разстояние # е по-добро съвпадение = сортирано (мачове, ключ = ламбда вал: val.distance) return len (мачове) cap = cv2.VideoCapture (0) # Заредете шаблона за изображение, това е нашето референтно изображение image_template = cv2.imread 'phone.jpg', 0) # image_template = cv2.imread ('images / kitkat.jpg', 0) while True: # Вземете изображения от уеб камерата ret, frame = cap.read () # Получете височина и ширина на височината на рамката на уеб камерата , width = frame.shape # Определете размерите на ROI Box (Обърнете внимание, че някои от тези неща трябва да са извън цикъла) 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)) # Начертайте правоъгълен прозорец за нашия област на интерес cv2.rectangle (frame, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), 255, 3) # Прозорец за наблюдение на изрязване, който дефинирахме по-горе cropped = frame # Flip frame direction horizontally frame = cv2.flip (frame, 1) # Получаване на брой съвпадения на ORB = ORB_detector (изрязано, image_template) # Показване на низ за състояние, показващ текущия номер. на съвпадения output_string = "Matches =" + str ( match) cv2.putText (frame, output_string, (50,450), cv2.FONT_HERSHEY_COMPLEX, 2, (250,0,150), 2) # Нашият праг за посочване на откриване на обект # За нови изображения или условия на осветление може да се наложи да експериментирате малко # Забележка: ORB детекторът, за да получи най-добрите 1000 съвпадения, 350 по същество е минимален праг на съвпадение от 35% = 250 # Ако съвпаденията надвишават нашите праг тогава обектът е открит, ако съвпада> праг: cv2.rectangle (рамка, (top_left_x, top_left_y), (bottom_right_x, bottom_right_y), (0,255,0), 3) cv2.putText (кадър, 'Обектът е намерен', (50, 50), cv2.FONT_HERSHEY_COMPLEX, 2, (0,255,0), 2) cv2.imshow ('Object Detector using ORB', frame) ако cv2.waitKey (1) == 13: # 13 е Въведете капачката за прекъсване на ключ .release () cv2.destroyAllWindows ()

Хистограма на ориентирани градиенти (HOG's)

Сега нека поговорим за различен дескриптор, който е хистограма на ориентирани градиенти (HOG).

HOG са доста готини и полезни дескриптори и те се използват широко и успешно за откриване на обекти, както се виждаше по-рано дескрипторите на изображения като SIFT и ORB, където трябва да изчислим ключови точки и след това да изчислим дескриптори от тези ключови точки, HOG правят този процес по различен начин. Той представлява обекти като единичен вектор на характеристика, за разлика от набор от вектори на характеристики, където всеки представлява сегмент от изображението. Това означава, че имаме един векторен елемент за цялото изображение.

Той се изчислява чрез плъзгащ се детектор на прозорец върху изображение, където HOG дескриптор се изчислява за всяка позиция. И тогава всяка позиция се комбинира за един векторен елемент.

Подобно на SIFT, мащабът на изображението се регулира чрез пирамидиране.

По-рано използвахме съвпадения като FLANN и BFMatcher, но HOG правят това по различен начин с помощта на SVM (поддръжка векторна машина) класификатори, където всеки HOG дескриптор, който се изчислява, се подава към SVM класификатор, за да определи дали обектът е намерен или не.

Ето връзката към страхотна книга от Dalal & Triggs за използването на HOGs за откриване на хора:

Хистограма на ориентираните градиенти (HOG's), стъпка по стъпка:

Разбирането на HOG може да бъде доста сложно, но тук ще се занимаваме само с теорията на HOG, без да навлизаме по-задълбочено в математиката, свързана с нея.

И така, нека направим тази снимка, тя е малко пикселизирана малко, а в горния ъгъл е 8x8 пикселно поле тук, така че в това поле изчисляваме градиентния вектор или ориентацията на ръба на всеки пиксел. Така че това означава, че в това поле изчисляваме вектора на градиента на изображението на пикселите вътре в кутията (те са някаква посока или поток от самата интензивност на изображението) и това генерира 64 (8 x 8) градиентни вектори, които след това се представят като хистограма. Така че представете си хистограма, която представлява всеки вектор на градиент. Така че, ако всички точки или интензивност лежат в една посока, хистограмата за тази посока, да речем 45 градуса, хистограмата ще има връх при 45 градуса.

И така, това, което правим сега, е да разделим всяка клетка на ъглови контейнери, където всеки контейнер съответства на посока на градиента (например x, y). В хартията Dalal и Triggs те използваха 9 кошчета 0-180 ° (по 20 ° всеки контейнер). Това ефективно намалява 64 вектора до само 9 стойности. Така че това, което направихме, е намалил размера, но запазил цялата ключова информация, която е необходима.

Следващата стъпка при изчисляването на свинете е нормализирането, ние нормализираме градиентите, за да осигурим неизменност спрямо промените в осветеността, т.е. Яркост и Контраст.

В това изображение стойностите на интензивността са показани в квадрата според съответната посока и всички имат разлика от 50 помежду си

∆ _H = 50, ∆ _v = 50; │∆│ = √50 ² +50 = 70,72, 70,72 / 100 = 0,707

Разделяме векторите на градиентните величини, получаваме 0,707 за всички, това е нормализиране.

По същия начин, ако променим интензивността или променим контраста, получаваме следните стойности.

∆ _H = 50, ∆ _v = 50; │∆│ = √50 ² +50 = 70,72, 70,72 / 100 = 0,707; ∆ _H = 100, ∆ _v = 100; │∆│ = √100 ² +100 = 141,42, 141,42 / 100 = 1,41

Нормализирането не се извършва на ниво клетка, а се извършва на ниво блок, така че тук блоковете са основно група от 4 клетки, това отчита съседните блокове, така че се нормализира, като се вземат предвид по-големите сегменти на изображението.

Сега нека разгледаме кода

импортиране на numpy като np импортиране на cv2 импортиране на matplotlib.pyplot като plt # Заредете изображение, след това изображение в сиво image = cv2.imread ('elephant.jpg') сиво = cv2.cvtColor (изображение, cv2.COLOR_BGR2GRAY) # Показване на оригиналното изображение cv2.imshow (' Входно изображение ', изображение) cv2.waitKey (0) # дефиниране на параметрите, размера на клетката и размера на блока # hxw в пиксели cell_size = (8, 8) # hxw в клетки block_size = (2, 2) # брой на кошовете за ориентация nbins = 9 # Използване на HOG Descriptor на OpenCV # winSize е размерът на изображението, изрязано до кратно на размера на клетката hog = cv2.HOGDescriptor (_winSize = (grey.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) # Създаваме числова форма на масив за създаване на hog_features n_cells = (grey.shape // cell_size, grey.shape // cell_size) # Първо индексираме блокове по редове. # hog_feats сега съдържа амплитудите на градиента за всяка посока, # за всяка клетка от нейната група за всяка група. Индексирането е по редове, а след това по колони. hog_feats = hog.compute (сиво).reshape (n_cells - block_size + 1, n_cells - block_size + 1, block_size, block_size, nbins).transpose ((1, 0, 2, 3, 4)) # Създайте нашия масив от градиенти с nbin размери за съхраняване на градиентни ориентации gradients = np.zeros ((n_cells, n_cells, nbins)) # Създайте масив от размери cell_count = np.full ((n_cells, n_cells, 1), 0, dtype = int) # Нормализация на блока за off_y в обхвата (block_size): за off_x в обхвата (block_size): градиенти - 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 # Средни градиенти на градиенти / = cell_count # Plot HOGs using Matplotlib # ъгъл е 360 / nbins * посока color_bins = 5 plt.pcolor (градиенти) plt.gca (). invert_yaxis () plt.gca (). set_aspect ('равно', регулируемо = 'поле') plt.colorbar () plt.show () cv2.destroyAllWindows ()

Изображението показва как входното изображение е представено като HOG представяне.

Каскадни класификатори на HAAR

Както вече беше обсъдено, можем да извлечем характеристики от изображение и да ги използваме за класифициране или откриване на обекти.

Какво представляват HAAR каскадните класификатори?

Метод за откриване на обект, който въвежда характеристиките на Haar в поредица от класификатори (каскада) за идентифициране на обекти в изображение. Те са обучени да идентифицират един тип обект, но можем да използваме няколко от тях паралелно, например да откриваме заедно очи и лица.

Обяснени класификатори на HAAR:

Класификаторите на HAAR се обучават с използване на много положителни изображения (т.е. изображения с присъстващ обект) и

отрицателни изображения (т.е. изображения без обект).

След като имаме тези изображения, след това извличаме функции, като използваме плъзгащи се прозорци от правоъгълни блокове. Тези характеристики (характеристики на HAAR) се оценяват еднократно и се изчисляват чрез изваждане на сумата от интензитета на пикселите под белите правоъгълници от черните правоъгълници.

Това обаче е смешен брой изчисления, дори за основен прозорец от 24 х 24 пиксела (180 000 генерирани функции).

Така изследователите измислят метод, наречен Integral Images, който изчислява това с четири референции на масиви. Въпреки това те все още имаха 180 000 функции и повечето от тях не добавиха реална стойност.

Увеличаване след това се използва за определяне на най-информативни функции, с Фройнд & Schapire на AdaBoost и го намерих най-информативните функции в изображението. Повишаването е процесът, чрез който използваме слаби класификатори, за да изградим силни класификатори, просто като назначаваме по-тежки наказания за неправилни класификации. Намаляване на 180 000 функции до 6000, което все още е доста малко.

В тези 6000 функции някои ще бъдат по-информативни от други. Така че, ако използвахме най-информативните функции, за да проверим първо дали регионът може потенциално да има лице (фалшивите положителни резултати няма да са голяма работа). Това елиминира необходимостта от изчисляване на всички 6000 функции наведнъж. Тази концепция се нарича Каскада от класификатори - за откриване на лица методът на Виола Джоунс използва 38 етапа.

Разпознаване на лице и очи

Така че след придобиване на някои теоретични познания за каскадите на HAAR, най-накрая ще го приложим, за да направим нещата доста ясни, ще разделим уроците на части, първо ще открием челно лице, след това ще преминем към откриване на челно лице с очи и накрая щяхме да направим откриване на лице и очи на живо през уеб камерата.

Така че за това ще използваме предварително обучени класификатори, предоставени от OpenCV като.xml файлове, xml означава разширяем език за маркиране, този език се използва за съхраняване на огромно количество данни, дори можете да изградите база данни върху него.

Можете да имате достъп до тези класификатори на тази връзка .

Разпознаване на лица

Нека се опитаме за фронтално разпознаване на лице, тук можете да имате достъп до каскадата на фронтален детектор на лице. Просто извлечете zip файла, за да получите xml файла.

import numpy като np import cv2 # Ние насочваме функцията CascadeClassifier на OpenCV към мястото, където се съхранява нашият # класификатор (XML файлов формат), не забравяйте да съхранявате кода и класификатора в същата папка face_cascade = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml') # Зареждане след това изображението ни го преобразува в сива скала image = cv2.imread ('Trump.jpg') grey = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) # Нашият класификатор връща ROI на откритото лице като кортеж # Съхранява горе вляво координата и долните десни координати # връща списъка със списъци, които са местоположението на различните открити лица. лица = face_cascade.detectMultiScale (сиво, 1.3, 5) # Когато не са открити лица, face_classifier връща и изпразва кортеж, ако face is (): print ("Няма намерени лица") # Прелистваме масива от нашите лица и изчертаваме правоъгълник # върху всяко лице във лица за (x, y, w, з) в лица: cv2.rectangle (изображение, (x, y), (x + w, y + h), (127,0,255), 2) cv2.imshow („Разпознаване на лица“, изображение) cv2.waitKey (0) cv2.destroyAllWindows ()

Сега нека комбинираме разпознаването на лице и око заедно, можете да имате достъп до каскадата детектор на очите в същия 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') v = cv2.c cv2.COLOR_BGR2GRAY) лица = face_classifier.detectMultiScale (сиво, 1.3, 5) # Когато не са открити лица, face_classifier връща и празен кортеж, ако face is (): print ("Няма намерено лице") за (x, y, w, h) в лица: cv2.rectangle (img, (x, y), (x + w, y + h), (127,0,255), 2) cv2.imshow ('img', img) roi_gray = сив roi_color = img eyes = eye_classifier.detectMultiScale (roi_gray) cv2.waitKey (0) за (ex, ey, ew, eh) в очите: 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)

Така че този код е същият като този за кода за разпознаване на лица, но тук сме добавили очни каскади и метод за тяхното откриване, както можете да видите, ние избрахме версията на лицето в сиво в мащаб като параметър за detectMultiScale за очите, което ни води до намаляване на изчисленията, тъй като ще откриваме очи само в тази област.

Откриване на лице и очи на живо

Така че досега сме правили откриване на лица и очи, сега нека внедрим същото с потока на видео на живо от уеб камерата. В това ще направим същото откриване на лицето и очите, но този път ще го направим за потока на живо от уеб камерата. В по-голямата част от приложението ще намерите лицето си, подчертано с поле около него, но тук направихме нещо различно, за да откриете, че лицето ви е изрязано и очите да се разпознаят само в това.

Така че тук внасяме както класификатора за лице и очи и дефинирахме функция за извършване на цялата обработка за откриване на лице и очи. И след това стартира потока от уеб камерата и извика функцията за разпознаване на лица за откриване на лицето и очите. Параметърът, който определяме във функцията за разпознаване на лица, са непрекъснатите изображения от потока на уеб камерата на живо

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): # Convert image to cv (img, cv2.COLOR_BGR2GRAY) лица = face_classifier.detectMultiScale (сиво, 1.3, 5) ако лица е (): върнете img за (x, y, w, h) в лица: x = x - 50 w = w + 50 y = y - 50 h = h + 50 cv2.правоъгълник (img, (x, y), (x + w, y + h), (255,0,0), 2) roi_gray = сив roi_color = img eyes = eye_classifier.detectMultiScale (roi_gray) за (ex, ey, ew, eh) в очите: 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) while True: ret, frame = cap.read () cv2.imshow ('Нашият Face Extractor', face_detector (frame)) ако cv2.waitKey (1) == 13: # 13 е Enter Key break cap.release () cv2.destroyAllWindows ()

Настройка на каскадни класификатори

Параметрите, дефинирани вътре в identifyMultiScale, различни от входното изображение, имат следното значение

нашияКласификатор. deteMultiScale (входно изображение, коефициент на мащаба, минимални съседи)

Scale Factor Указва колко намаляваме размера на изображението всеки път, когато мащабираме. Например при разпознаване на лица обикновено използваме 1.3. Това означава, че намаляваме изображението с 30% всеки път, когато се мащабира. По-малките стойности, като 1,05, ще отнемат повече време за изчисляване, но ще увеличат скоростта на откриване.

Мин съседи Указва броя на съседите, които всеки потенциален прозорец трябва да има, за да го счита за положително откриване. Обикновено се настройва между 3-6. Той действа като настройка на чувствителността, понякога ниските стойности ще открият множество лица върху едно лице. Високите стойности ще осигурят по-малко фалшиви положителни резултати, но може да пропуснете някои лица.

Откриване на автомобили и пешеходци във видеоклипове

Сега ще открием пешеходци и автомобили във видеоклипове, използвайки каскадите HAAR, но в случай, че не се зарежда видео и кодът се компилира без грешка, трябва да изпълните следните стъпки:

Ако след стартиране на код не се зареди видео, може да се наложи да копирате нашия opencv_ffmpeg.dl от : opencv \ sources \ 3rdparty \ ffmpeg, за да го поставите там, където е инсталиран вашият питон, напр. C: \ Anaconda2

След като бъде копиран, ще трябва да преименувате файла според версията на OpenCV, която използвате. Напр. Ако използвате OpenCV 2.4.13, тогава преименувайте файла като: opencv_ffmpeg2413_64.dll или opencv_ffmpeg2413.dll (ако сте с помощта на машина X86) opencv_ffmpeg310_64.dll или opencv_ffmpeg310.dll (ако използвате машина X86)

За да разберете къде е инсталиран python.exe, просто изпълнете тези два реда код, той ще отпечата местоположението, където е инсталиран python.

импортиране на sys печат (sys.executable)

Сега, ако сте направили тези стъпки успешно, нека преминем към кода за откриване на пешеходци, Можете да имате каскадата за откриване на пешеходци и от прикачения тук zip файл.

import cv2 import numpy като np # Създайте нашия класификатор на тялото body_classifier = cv2.CascadeClassifier ('haarcascade_fullbody.xml') # Инициирайте видеозаснемане за видео файл, тук използваме видео файла, в който пешеходците ще бъдат открити cap = cv2.VideoCapture ('walking.avi') # Цикъл, след като видеото се зареди успешно, докато cap.isOpened (): # Четене на всеки кадър от видеото , frame = cap.read () # тук преоразмеряваме кадъра до половината от неговия размер, ние правим, за да ускорим класификацията #, тъй като по-големите изображения имат много повече прозорци за плъзгане, така че като цяло намаляваме разделителната способност # на видео наполовина това е, което показва 0.5, а също така използваме по-бърз метод за интерполация, който е #interlinear frame = cv2.resize (frame, None, fx = 0.5, fy = 0.5, interpolation = cv2.INTER_LINEAR) grey = cv2. cvtColor (frame, cv2.COLOR_BGR2GRAY) # Предаване на рамка на нашите тела класификатор на тела = body_classifier.detectMultiScale (сиво, 1.2, 3) # Извличане на ограничителни полета за всички тела, идентифицирани за (x, y, w, h) в тела: cv2. правоъгълник (рамка, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow („Пешеходци“, рамка) ако cv2.waitKey (1) == 13: # 13 е Enter Key break cap.release () cv2.destroyAllWindows ()

След успешното откриване на пешеходец във видео, нека преминем към кода за откриване на автомобили. От тук можете да имате каскадата за откриване на пешеходци.

import cv2 time import import numpy as np # Създайте нашия класификатор на тялото car_classifier = cv2.CascadeClassifier ('haarcascade_car.xml') # Иницииране на заснемане на видео за видео файл cap = cv2.VideoCapture ('cars.avi') # Цикъл, след като видеото е успешно зарежда се докато cap.isOpened (): time.sleep (.05) # Прочетете първия кадър ret, frame = cap.read () grey = cv2.cvtColor (frame, cv2.COLOR_BGR2GREY) # Предаване на рамка към нашата класификация на автомобили cars = car_classifier.detectMultiScale (сиво, 1.4, 2) # Извличане на ограничителни кутии за всички тела, идентифицирани за (x, y, w, h) в автомобили: cv2.rectangle (рамка, (x, y), (x + w, y + h), (0, 255, 255), 2) cv2.imshow ('Cars', frame) ако cv2.waitKey (1) == 13: # 13 е Enter Key break break.release () cv2.destroyAllWindows ()

Забелязали сте, че сме добавили time.sleep (.05) , това е просто забавяне на честотата на кадрите, за да можете да потвърдите, че всички автомобили са правилно идентифицирани, или можете лесно да го премахнете, просто като добавите етикет за коментар към него.

Тази статия е посочена от Master Computer Vision ™ OpenCV4 в Python с курс за дълбоко обучение на Udemy, създаден от Rajeev Ratan, абонирайте се, за да научите повече за Computer Vision и Python.