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

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

Компютрите са станали толкова сложни, че са обучени да мислят като хората.
Да!

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

Много статии, които ще видите там, трябва да спрат с простото разпознаване на лица, но в тази статия ще бъдат разгледани не само разпознаването на лица, но и разпознаването на лица.

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

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

За да инсталираме Open CV, можем да направим това с помощта на командата pip.

pip инсталирайте opencv-python

Също така ще използваме пакета numpy в тази статия, който трябва да бъде инсталиран заедно с OpenCV с помощта на горната команда.

Ако numpy не се инсталира, можете лесно да го направите, като използвате командата по-долу:

pip инсталирайте numpy

За да потвърдите, че вашият OpenCV е инсталиран, когато активирате интерактивната среда на Python, опитайте да го импортирате, като използвате:

импортиране на cv2

Ако не получите грешка, можете да продължите.

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

Ще ни трябва Haar Cascade, предоставена от Open CV. Този файл може да бъде получен от директорията opencv, която е cv2 / data / haarcascade_frontalface_default.xml на моята машина трябва да е същото и на вашата машина. Копирайте файла в папката, където искате да направите разпознаването на лица.

А сега нека да влезем в дебелите неща.
Бихме се опитали да получим нашата уеб камера, за да вземем снимките, необходими за набора от данни.

импортиране на cv2
vid_cam = cv2.VideoCapture (0)
детектор на лице = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ')
face_id = 1
брой = 0
докато (vid_cam.isOpened ()):
ret, image_frame = vid_cam.Прочети()
сиво = cv2.cvtColor (image_frame, cv2.COLOR_BGR2GREY)
лица = детектор на лице.deteMultiScale (сиво, 1.3, 5)
за (x, y, w, h) в лица:
cv2.правоъгълник (image_frame, (x, y), (x + w, y + h), (255,0,0), 2)
преброяване + = 1
cv2.imwrite ("набор от данни / потребител."+ str (face_id) + '.'+ str (брой) + ".jpg ", сиво [y: y + h, x: x + w])
cv2.imshow ('рамка', image_frame)
ако cv2.waitKey (100) & 0xFF == ord ('q'):
почивка
elif брой> 100:
почивка
vid_cam.освобождаване ()
cv2.Унищожи всичкиWindows ()

Така че, за да обясним какво прави всеки ред код:

импортиране на cv2

Ето командата, която казва на python да включи външна библиотека, която да се използва в този код, в този случай това е Open CV.

vid_cam = cv2.VideoCapture (0)

Този код призовава импортираната библиотека на Open CV да започне да улавя и уеб камерата се стартира в този момент. Ако Open CV не поддържа вашата уеб камера, кодът тук ще се провали.

детектор на лице = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ')

За да можем да извършим откриване на изображения, този код е необходим. Отвореното CV използва 'haarcascade_frontalface_default.xml 'за каскадна класификация. След това полученият обект се съхранява в променливата face_detector.

face_id = 1

Ето един случай на задаване на идентификационния номер на лицето, така че първото лице получава идентификатор 1.

брой = 0

Ще направим няколко изображения, тъй като Open CV трябва да обучава изображения, за да може да разпознава лица, променливата count служи като брой изображения.

докато (vid_cam.isOpened ()):

Това позволява да продължат следните операции, при условие че видеокамерата е отворена. Методът isOpened () връща True или False.

ret, image_frame = vid_cam.Прочети()

Тук, vid_cam.read () разглежда видеозаснемането и след това улавя кадъра, който се съхранява в променливата image_frame, ако операцията е успешна, булевото True се връща и съхранява в променливата ret

сиво = cv2.cvtColor (image_frame, cv2.COLOR_BGR2GREY)

Методът cvtColor () се използва за преобразуване на рамката на изображението в желания тип цвят. В този случай сме го преобразували в сива скала.

лица = детектор на лице.deteMultiScale (сиво, 1.3, 5)

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

за (x, y, w, h) в лица:

Тук циклично преминаваме през лицата и неговите размери, където x и y означават координатите, а w и h съответно ширината и височината.

cv2.правоъгълник (image_frame, (x, y), (x + w, y + h), (255,0,0), 2)

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

преброяване + = 1

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

cv2.imwrite ("набор от данни / потребител."+ str (face_id) + '.'+ str (брой) + ".jpg ", сиво [y: y + h, x: x + w])

Изрязаното изображение се записва с името Потребител (face_id).(броя).jpg и се поставя в папка, наречена набор от данни.

cv2.imshow ('рамка', image_frame)

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

ако cv2.waitKey (100) & 0xFF == ord ('q'):
почивка

След всяка снимка на потребителя е позволено да спре програмата да прави повече снимки, което може да се направи чрез натискане на 'q' на клавиатурата поне 100ms.

elif брой> 100:
почивка

Това, което прави този код, е да спре да работи видеото в момента, в който са направени 100 снимки, независимо дали потребителят иска да направи повече или не.

vid_cam.освобождаване ()

Тук уеб камерата е затворена и не просто спря да прави снимки.

cv2.Унищожи всичкиWindows ()

Тогава всички прозорци OpenCV се отвориха бяха унищожени и кодът завършва.

След като приключихме с това, можем да тренираме набора от изображения:

внос cv2, os
импортиране на numpy като np
от PIL import Image
разпознавател = cv2.лице.createLBPHFaceRecognizer ()
детектор = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml ");
def getImagesAndLabels (път):
imagePaths = [os.път.join (path, f) for f in os.listdir (път)]
faceSamples = []
идентификатори = []
за imagePath в imagePaths:
PIL_img = Изображение.отворен (imagePath).конвертиране ('L')
img_numpy = np.масив (PIL_img, 'uint8')
id = int (os.път.разделяне (imagePath) [- 1].разделен (".") [1])
лица = детектор.deteMultiScale (img_numpy)
за (x, y, w, h) в лица:
faceSamples.добавяне (img_numpy [y: y + h, x: x + w])
идентификатори.добавяне (id)
return faceSamples, ids
лица, идентификатори = getImagesAndLabels ('набор от данни')
разпознавател.влак (лица, np.масив (идентификатори))
разпознавател.save ('обучител / обучител.yml ')

Нека да обясним и този код:

внос cv2, os

Подобно на другия код, тук ние импортираме OpenCV и os, които биха ни били необходими за пътя на файла.

импортиране на numpy като np

Също така импортираме библиотеката numpy, която ще се използва за изчисляване на матрицата (матрицата е просто подреждане на масиви).

от PIL import Image

Импортираме библиотеката на изображения на Python и след това от нея получаваме библиотеката на изображения и от този пакет.

разпознавател = cv2.лице.createLBPHFaceRecognizer ()

Това, което прави, е да приложи метода createLBPHFaceRecognizer () към cv2.обект лице, това би спомогнало за лесното разпознаване на лица, тъй като не е нужно да измисляме собствен набор от алгоритми.

детектор = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml ");

Ако сте следвали урока, бихте попадали на това и преди. Помага при разпознаването на лица, използвайки “haarcascade_frontalface_default.xml ”за каскадната класификация.

def getImagesAndLabels (път):

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

imagePaths = [os.път.join (path, f) for f in os.listdir (път)]

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

faceSamples = []

Това инициализира списък с проби, той е празен в този момент, но лица ще бъдат добавени, докато кодът работи.

идентификатори = []

Инициализирайте списък с идентификатори, който първоначално е празен.

за imagePath в imagePaths:

Запомнете кода, който е проверил файловете с изображения в директорията? Да? Сега ще преминем през всеки от тези файлове и ще извършим операции върху тях.

PIL_img = Изображение.отворен (imagePath).конвертиране ('L')

Сега първото нещо, което правим с изображението, е да го преобразуваме в сива скала и този код прави това.

img_numpy = np.масив (PIL_img, 'uint8')

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

id = int (os.път.разделяне (imagePath) [- 1].разделен (".") [1])

Ако си припомните файла, който получава изображенията, ще си спомните, че ние именувахме файловете Потребител (face_id).броя.jpg. И така, тук разделяме имената с „.”И след това извличаме face_id и присвояваме на променлива тук. Ще ни трябва идентификационният номер за разпознаване.

лица = детектор.deteMultiScale (img_numpy)

От масива numpy методът deteMultiScale () ще се опита да открие лицата от шаблона, който намира в масива numpy. След това той присвоява стойностите в променливата лица.

за (x, y, w, h) в лица:

Тук преглеждаме стойностите, присвоени на променливата. Стойностите тук са координатите x и y, които бихме могли да вземем като начало, а след това w и h, съответно за ширина и височина.

faceSamples.добавяне (img_numpy [y: y + h, x: x + w])

По-рано създадохме списък с образци на лица, но той беше празен. Тук получаваме да добавяме лица към този списък и добавяме y към h, за да получим двете стойности на координатите y и същото се прави с x.

идентификатори.добавяне (id)

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

return faceSamples, ids

След всичко това връщаме списъка с образци на лица и списъка с идентификатори.

лица, идентификатори = getImagesAndLabels ('набор от данни')

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

разпознавател.влак (лица, np.масив (идентификатори))

Тук се случва истинското обучение. Приложихме метода createLBPHFaceRecognizer () по-рано и го присвоихме на разпознаваща променлива. Време е за тренировка!

разпознавател.save ('обучител / обучител.yml ')

След тренировка можем да запазим резултатите от обучението.
След като стартира кода, той създава файл, наречен треньор.yml, който след това ще се използва от кода за разпознаване на лица.

Ето кода за разпознаване на лица:

импортиране на cv2
импортиране на numpy като np
разпознавател = cv2.лице.createLBPHFaceRecognizer ()
разпознавател.load ('треньор / обучител.yml ')
cascadePath = "haarcascade_frontalface_default.xml "
faceCascade = cv2.CascadeClassifier (cascadePath)
шрифт = cv2.FONT_HERSHEY_SIMPLEX
cam = cv2.VideoCapture (0)
докато е вярно:
ret, im = cam.Прочети()
сиво = cv2.cvtColor (im, cv2.COLOR_BGR2GREY)
лица = faceCascade.deteMultiScale (сиво, 1.2,5)
за (x, y, w, h) в лица:
cv2.правоъгълник (im, (x-20, y-20), (x + w + 20, y + h + 20), (0,255,0), 4)
Id = разпознавател.предсказване (сиво [y: y + h, x: x + w])
ако (Id == 1):
Id = "Nazmi"
друго:
Id = "Неизвестно"
cv2.правоъгълник (im, (x-22, y-90), (x + w + 22, y-22), (0,255,0), -1)
cv2.putText (im, str (Id), (x, y-40), font, 2, (255,255,255), 3)
cv2.imshow ('im', im)
ако cv2.waitKey (10) & 0xFF == ord ('q'):
почивка
камера.освобождаване ()
cv2.Унищожи всичкиWindows ()

Ако сте следвали статията от самото начало, ние сме правили това и преди. Ако не сте го направили любезно.

разпознавател.load ('треньор / обучител.yml ')

Не забравяйте, че обучихме разпознавателя и запазихме файл? Да? Зареждаме този файл сега.

cascadePath = "haarcascade_frontalface_default.xml "

Бихме работили с файла haarcascade и тук сме присвоили името на файла на променлива.

# Създайте класификатор от предварително изграден модел
faceCascade = cv2.CascadeClassifier (cascadePath)

Тук можем да извършим класификация на Cascade върху файла haarcascade.

шрифт = cv2.FONT_HERSHEY_SIMPLEX

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

cam = cv2.VideoCapture (0)

И преди сме били тук, но този път е време да разпознаем лицата. Ако не знаете какво прави този код, той стартира уеб камерата.

докато е вярно:
ret, im = cam.Прочети()
сиво = cv2.cvtColor (im, cv2.COLOR_BGR2GREY)
лица = faceCascade.deteMultiScale (сиво, 1.2,5)
за (x, y, w, h) в лица:

Всичко това е направено преди, любезно проверете кода, който е бил използван за запазване на изображения, ако не знаете какво прави кодът.

cv2.правоъгълник (im, (x-20, y-20), (x + w + 20, y + h + 20), (0,255,0), 4)

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

Id = разпознавател.предсказване (сиво [y: y + h, x: x + w])

Вече заредихме файла на влака в разпознавателя, така че той е в състояние да разпознае лицето сега.

ако (Id == 1):
Id = "Себе си"
друго:
Id = "Неизвестно"

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

cv2.правоъгълник (im, (x-22, y-90), (x + w + 22, y-22), (0,255,0), -1)
cv2.putText (im, str (Id), (x, y-40), font, 2, (255,255,255), 3)

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

cv2.imshow ('im', im)

Тук видеокадърът се показва с ограничения правоъгълник.

ако cv2.waitKey (10) & 0xFF == ord ('q'):
почивка
камера.освобождаване ()
cv2.Унищожи всичкиWindows ()

Така че, когато сте готови, можете да спрете програмата, като натиснете клавиша „q“ и тя спира уеб камерата и я затваря.

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

Можете да намерите изходния код, използван в неговото репо github. Също така ни пишете, ако имате коментари или искате да обсъдите @linuxhint