Блог Программиста: Python OpenCv распознавание лиц и определение расстояния до них (версия простая )

Идеи, мысли, проблемы.

среда, 3 октября 2012 г.

Python+OpenCv распознавание лиц и определение расстояния до них (версия простая )

Мы живём в счастливую для лентяев эпоху — вам уже не нужно купаться в сложной математической теории. Всё сделано за вас, по крайней мере на таком элементарном уровне. Распознавание лиц происходит по признакам Хаара. «Эталон» лица уже давно создан и хорошо обучен, находится он в файле haarcascade_frontalface_alt.xml . Там находится, так называемая, модель лица, а именно «Идеальное» лицо в виде примитивов Хаара :

Первый бой (вывод видео на экран) :

Для начала давайте на экран выведем видео поток. С помощью OpenCV это делается элементарно.

Код прост:
Я создаю объект камеры, которая подхватит первую попавшуюся(ваша web-ка)
И всё последующее время я буду читать 1 кадр из камеры и выводить его на экран, каждые десять миллисекунд опрашивать клавиатуру, и, если нажата клавиша с кодом 27(Esc) ,то выйду из бесконечного цикла прямо в ОС.

Битва вторая( использование микроскопа по назначению):

Использовать OpenCV для вывода видео на экран — забивание гвоздей микроскопом. Не будем столь брутальны — начнём распознавание лиц:

HaarDetectObjects принимает 3 параметра ( где_искать,что искать, где_хранить_промежуточные_данные)
где_хранить_промежуточные_данные — область памяти, которую можно выделить функцией CreateMemStorage.

Последний бой ( проявите каплю своего творчества):

Если, проделав это всё, вы гордо скажите, что вы программист, я плюну вам в лицо. Что вы сделали? Ну хоть малость своих мыслей тут? Мы использовали стандартные функции для совершения достаточно тривиальных действий — ни капли математического аппарата. Давайте-же прибавим! А что тут можно сделать? Определим расстояние до лица!
Попытаемся понять, как работает наша камера:

А значит это то , что отношение DE/CH равно отношению AB/FC. Поднеся линейку в 10 сантиметров к веб-камере так, чтоб она поместилась полностью, и измерив расстояние до веб-камеры от линейки, мы можем узнать отношение высоты матрицы нашей камеры к её фокусному расстоянию.( у меня это 1.6) .
Средняя высота лица человека — 15 сантиметров.

Получив из OpenCV размер квадрата лица, просто вычислить, сколько процентов всей высоты кадра оно занимает. Несложно додуматься, что Если лицо влезает в камеру всеми своими 15 сантиметрами , то до веб-камеры — (AB/FC)*12. Если лицо занимает меньше 100% пространства, то оно более удалено. Давайте определим , насколько.

Что нам отсюда известно?
Мы знаем, отношение AB/FE — это есть наше фокальное расстояние, обозначим его как focal.
реальные размеры AB.

Нам надо узнать расстояние FG.
Треугольники AFB и DFC подобны, значит FE/FG=AB/DC. Из этого равенства видно, что если FG увеличивается в M раз, то либо DC увеличивается в M раз, либо AB уменьшается в M раз. AB уменьшится не может — это реальный размер лица, он всегда 15 сантиметров, А вот DC — может, это размер лица на фотографии, чем лицо дальше, тем размер его меньше. Исходя из этого, можно сделать вывод, что если DC уменьшилось в M раз( или на N%) ,то и FG уменьшилось так же в M раз( или на N%). Если DC у нас равно AB, то GF = EF, если DC меньше AB в M раз (илиN%),то и FG

Теперь ближе к коду:

Как видите, я задаю отношение размера матрицы к фокальному расстоянию и размер лица человека, и, исходя из этого, считаю его удалённость, в зависимости от процентов занимаемого им места на экране.

Вот и все пироги, ничего сложного. В следующий раз я предоставлю программу для детектирования любого объекта, стоит вам его выделить мышкой.

Шпаргалка по OpenCV — Python

• Переводы , 3 мая 2019 в 11:06
• Александр Ланский

Что такое OpenCV?

Библиотека компьютерного зрения и машинного обучения с открытым исходным кодом. В неё входят более 2500 алгоритмов, в которых есть как классические, так и современные алгоритмы для компьютерного зрения и машинного обучения. Эта библиотека имеет интерфейсы на различных языках, среди которых есть Python (в этой статье используем его), Java, C++ и Matlab.

Содержание

1. Установка.
2. Импорт и просмотр изображения.
3. Обрезка.
4. Изменение размера.
5. Поворот.
6. Градация серого и порог.
7. Размытие/сглаживание.
8. Рисование прямоугольников.
9. Рисование линий.
10. Текст на изображении.
11. Распознавание лиц.
12. Contours — распознавание объектов.
13. Сохранение изображения.

Установка

Инструкцию по установке на Windows можно посмотреть здесь, а на Linux — здесь.

Импорт и просмотр изображения

Примечание При чтении способом выше изображение находится в цветовом пространстве не RGB (как все привыкли), а BGR. Возможно, в начале это не так важно, но как только вы начнёте работать с цветом — стоит знать об этой особенности. Есть 2 пути решения:

1. Поменять местами 1-й канал (R — красный) с 3-м каналом (B — синий), и тогда красный цвет будет (0,0,255) , а не (255,0,0) .
2. Поменять цветовое пространство на RGB:

И тогда в коде работать уже не с image , а с rgb_image .

Примечание Чтобы закрыть окно, в котором отображается изображение, нажмите любую клавишу. Если использовать кнопку закрытия окна, можно наткнуться на подвисания.

На протяжении статьи для вывода изображений будет использоваться следующий код:

Кадрирование

Пёсик после кадрирования

Где image[10:500, 500:2000] — это image[y:y + высота, x:x + ширина] .

Изменение размера

После изменения размера на 20 %

Эта функция учитывает соотношение сторон оригинального изображения. Другие функции изменения размера изображений можно увидеть здесь.

Поворот

Пёсик после поворота на 180 градусов

image.shape возвращает высоту, ширину и каналы. M — матрица поворота — поворачивает изображение на 180 градусов вокруг центра. -ve — это угол поворота изображения по часовой стрелке, а +ve , соответственно, против часовой.

Перевод в градации серого и в чёрно-белое изображение по порогу

Пёсик в градациях серого

gray_image — это одноканальная версия изображения.

Функция threshold возвращает изображение, в котором все пиксели, которые темнее (меньше) 127 заменены на 0, а все, которые ярче (больше) 127, — на 255.

20 – 21 июня , онлайн, беcплатно

Для ясности другой пример:

Здесь всё, что темнее, чем 150, заменяется на 10, а всё, что ярче, — на 200.

Остальные threshold-функции описаны здесь.

Размытие/сглаживание

Функция GaussianBlur (размытие по Гауссу) принимает 3 параметра:

1. Исходное изображение.
2. Кортеж из 2 положительных нечётных чисел. Чем больше числа, тем больше сила сглаживания.
3. sigmaX и sigmaY. Если эти параметры оставить равными 0, то их значение будет рассчитано автоматически.

Больше про размытие здесь.

Рисование прямоугольников

Обводим прямоугольником мордочку пёсика

Эта функция принимает 5 параметров:

1. Само изображение.
2. Координата верхнего левого угла (x1, y1) .
3. Координата нижнего правого угла (x2, y2) .
4. Цвет прямоугольника (GBR/RGB в зависимости от выбранной цветовой модели).
5. Толщина линии прямоугольника.

Рисование линий

2 пёсика, разделённые линией

Функция line принимает 5 параметров:

1. Само изображение, на котором рисуется линия.
2. Координата первой точки (x1, y1) .
3. Координата второй точки (x2, y2) .
4. Цвет линии (GBR/RGB в зависимости от выбранной цветовой модели).
5. Толщина линии.

Текст на изображении

Изображение с текстом

Функция putText принимает 7 параметров:

1. Непосредственно изображение.
2. Текст для изображения.
3. Координата нижнего левого угла начала текста (x, y) .
4. Используемый шрифт.
5. Размер шрифта.
6. Цвет текста (GBR/RGB в зависимости от выбранной цветовой модели).
7. Толщина линий букв.

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

На этот раз без пёсиков.

Лиц обнаружено: 2

detectMultiScale — общая функция для распознавания как лиц, так и объектов. Чтобы функция искала именно лица, мы передаём ей соответствующий каскад.

Функция detectMultiScale принимает 4 параметра:

1. Обрабатываемое изображение в градации серого.
2. Параметр scaleFactor . Некоторые лица могут быть больше других, поскольку находятся ближе, чем остальные. Этот параметр компенсирует перспективу.
3. Алгоритм распознавания использует скользящее окно во время распознавания объектов. Параметр minNeighbors определяет количество объектов вокруг лица. То есть чем больше значение этого параметра, тем больше аналогичных объектов необходимо алгоритму, чтобы он определил текущий объект, как лицо. Слишком маленькое значение увеличит количество ложных срабатываний, а слишком большое сделает алгоритм более требовательным.
4. minSize — непосредственно размер этих областей.

Contours — распознавание объектов

Распознавание объектов производится с помощью цветовой сегментации изображения. Для этого есть две функции: cv2.findContours и cv2.drawContours .

В этой статье детально описано обнаружение объектов с помощью цветовой сегментации. Всё, что вам нужно для неё, находится там.

Сохранение изображения

Заключение

OpenCV — отличная библиотека с лёгкими алгоритмами, которые могут использоваться в 3D-рендере, продвинутом редактировании изображений и видео, отслеживании и идентификации объектов и людей на видео, поиске идентичных изображений из набора и для много-много чего ещё.

Эта библиотека очень важна для тех, кто разрабатывает проекты, связанные с машинным обучением в области изображений.

Обнаружение и распознавание лиц на фотографиях с помощью OpenCV и Python

Изображения составляют большой объем данных, который генерируется каждый день, а потому возможность их обработки очень важна. Одним из методов обработки изображений является распознавание лиц. Обнаружение лиц – это область обработки изображений, которая использует машинное обучение для поиска лиц на изображениях.

Каскады Хаара (Haar Cascade) – это метод обнаружения объектов, используемый для определения местоположения объектов на изображениях. Алгоритм обучается на большом количестве положительных и отрицательных образцов: положительные образцы – это изображения, которые содержат интересующий объект, а отрицательные образцы – это изображения, которые содержат что угодно, кроме искомого объекта. После обучения классификатор может найти интересующий объект на новых изображениях.

В этом мануале мы будем использовать предварительно обученную модель Хаара, OpenCV и Python для обнаружения и извлечения лиц из изображения. OpenCV – это программная библиотека с открытым исходным кодом, которая используется для обработки изображений.

Требования

Для работы вам понадобится подготовленная среда Python 3, включая pip и venv. Настроить всё вам помогут эти мануалы:

1: Настройка локальной среды

Прежде чем приступить к написанию кода, сначала вам нужно подготовить свое рабочее пространство и установить пару зависимостей.

Создайте каталог для проекта:

Перейдите в него:

Затем нужно создать виртуальную среду для этого проекта. Виртуальная среда изолирует разные проекты, которые размещены в рамках одной операционной системы, благодаря чему их зависимости не будут конфликтовать.

Создайте виртуальную среду по имени face_scrapper:

python3 -m venv face_scrapper

Активируйте изолированную среду:

Теперь в командной строке появится префикс – имя вашей виртуальной среды:

Теперь, когда вы активировали свою виртуальную среду, вы можете использовать nano или другой текстовый редактор для создания файла require.txt. Этот файл указывает зависимости Python.

Далее вам нужно установить три зависимости:

• numpy: это библиотека Python, которая обеспечивает поддержку больших многомерных массивов. Она также включает в себя большой набор математических функций для работы с массивами.
• opencv-utils: расширенная библиотека для OpenCV, которая включает вспомогательные функции.
• opencv-python: основной модуль OpenCV, который использует Python.

Добавьте в файл следующие зависимости:

numpy
opencv-utils
opencv-python

Сохраните и закройте файл.

Установите зависимости, передав файл requirements.txt пакетному менеджеру Python, pip. Флаг –r определяет расположение файла requirements.txt.

pip install -r requirements.txt

Итак, виртуальная среда проекта включена, необходимые библиотеки установлены. Теперь можно написать код для распознавания лиц на входных изображениях.

2: Написание и запуск детектора лиц

В этом разделе вы напишете код, который будет принимать изображение в качестве входных данных и возвращать две вещи:

• Количество лиц, найденных на входном изображении.
• Новое изображение с прямоугольником вокруг каждого обнаруженного лица.

Создайте файл для хранения вашего кода:

В этом новом файле начните писать свой код, сначала импортировав необходимые библиотеки. Здесь нужно импортировать два модуля: cv2 и sys. Модуль cv2 импортирует библиотеку OpenCV в программу, а sys – обычные функции Python, которые будет использовать ваш код (такие как argv).

import cv2
import sys

Далее нужно указать, что входное изображение будет передано скрипту во время выполнения в качестве аргумента. Способ чтения первого аргумента в Python состоит в том, чтобы присвоить переменной значение, возвращаемое функцией sys.argv[1]:

Обычная практика обработки изображений – сначала преобразовать входное изображение в оттенки серого. Это связано с тем, что обнаружение яркости, в отличие от цвета, обычно дает лучшие результаты при обнаружении объектов. Добавьте следующий код, чтобы взять входное изображение в качестве аргумента и преобразовать его в оттенки серого:

.
image = cv2.imread(imagePath)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

Функция .imread() берет входное изображение, которое передается в качестве аргумента скрипту, и преобразовывает его в объект OpenCV. Затем функция OpenCV .cvtColor() преобразует объект входного изображения в объект в градациях серого.

Теперь, когда вы добавили код для загрузки изображения, вам нужно поместить в файл код, который распознает лица:

.
faceCascade = cv2.CascadeClassifier(cv2.data.haarcascades + «haarcascade_frontalface_default.xml»)
faces = faceCascade.detectMultiScale(
gray,
scaleFactor=1.3,
minNeighbors=3,
minSize=(30, 30)
)
print(«Found <0>Faces!».format(len(faces)))

Этот код создаст объект faceCascade, который загрузит файл каскада Хаара с помощью метода cv2.CascadeClassifier. Это позволяет Python и коду использовать Haar Cascade.

Затем код применяет метод .detectMultiScale() к объекту faceCascade. Это создает список прямоугольников для всех обнаруженных лиц на изображении. Список прямоугольников представляет собой набор расположений пикселей в форме Rect(x,y,w,h).

Вот список других параметров, использованных в этом коде:

• gray: указывает на использование объекта изображения OpenCV в оттенках серого, который вы загрузили ранее.
• scaleFactor: этот параметр указывает скорость уменьшения размера изображения при каждом масштабе. Модель использует фиксированный масштаб во время обучения, поэтому для лучшего обнаружения входные изображения можно уменьшить. Этот процесс останавливается после достижения порогового предела, определенного maxSize и minSize.
• minNeighbors: этот параметр указывает, сколько соседей (или обнаружений) должен иметь каждый прямоугольник-кандидат для его сохранения. Более высокое значение может привести к меньшему количеству ложных срабатываний, но слишком высокое значение может исключить истинные положительные результаты.
• minSize: позволяет определить минимально возможный размер объекта в пикселях. Объекты, меньшие, чем этот параметр, будут проигнорированы.

После создания списка прямоугольников лица подсчитываются с помощью функции len. Количество обнаруженных лиц затем возвращается как результат после запуска сценария.

Теперь используйте метод .rectangle(), чтобы нарисовать прямоугольник вокруг обнаруженного лица:

.
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)

Этот код использует цикл for для итерации по списку расположений пикселей, возвращаемых методом faceCascade.detectMultiScale для каждого обнаруженного объекта. Метод rectangle будет принимать четыре аргумента:

• image рисует прямоугольники на оригинальном изображении.
• (x,y), (x+w, y+h) – это четыре расположения пикселей обнаруженного объекта. Метод rectangle с их помощью нарисует прямоугольник вокруг найденного лица на входном изображении.
• (0, 255, 0) задает цвет формы. Этот аргумент передается как кортеж BGR. Например, чтобы прямоугольник был синим, нужно использовать (255, 0, 0). Мы используем зеленый.
• 2 — толщина линии в пикселях.

Теперь, когда вы добавили код для рисования прямоугольников, используйте метод .imwrite(), чтобы записать новое изображение в локальную файловую систему как face_detected.jpg. Этот метод вернет true, если запись была успешной, и false, если записать новое изображение не удалось.

.
status = cv2.imwrite(‘faces_detected.jpg’, image)

Теперь добавьте этот код, чтобы вывести в консоль статус true или false функции .imwrite(). Это даст вам знать, была ли запись изображения успешной после запуска скрипта.

.
print («Image faces_detected.jpg written to filesystem: «,status)

В результате получился такой скрипт:

import cv2
import sys
imagePath = sys.argv[1]
image = cv2.imread(imagePath)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
faceCascade = cv2.CascadeClassifier(cv2.data.haarcascades + «haarcascade_frontalface_default.xml»)
faces = faceCascade.detectMultiScale(
gray,
scaleFactor=1.3,
minNeighbors=3,
minSize=(30, 30)
)
print(«[INFO] Found <0>Faces!».format(len(faces)))
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
status = cv2.imwrite(‘faces_detected.jpg’, image)
print(«[INFO] Image faces_detected.jpg written to filesystem: «, status)

Убедившись, что все введено правильно, сохраните и закройте файл.

Примечание: Этот код взят из публичной документации OpenCV.

Ваш код готов, пора запустить скрипт.

3: Запуск скрипта

Теперь вам нужно какое-нибудь тестовое изображение для проверки вашего скрипта. Когда вы найдете изображение, которое хотите использовать для тестирования, сохраните его в одном каталоге со скриптом app.py.

curl -O https://path/to/input_image

Когда у вас будет фотография, на которой нужно обнаружить лица, запустите скрипт и укажите путь к изображению:

python app.py path/to/input_image

Вы должны получить такой результат:

[INFO] Found 4 Faces!
[INFO] Image faces_detected.jpg written to filesystem: True

Вывод true говорит, что обработанное изображение было успешно сохранено в файловой системе. Откройте изображение на локальном компьютере, чтобы увидеть изменения в новом файле.

Вы должны увидеть, что ваш скрипт обнаружил лица во входном изображении и нарисовал прямоугольники вокруг, чтобы отметить их. Теперь попробуйте использовать эти пиксели для извлечения лиц из изображения.

4: Извлечение лиц и сохранение их на локальной машине (опционально)

Ранее вы написали код OpenCV и каскад Хаара для обнаружения и рисования прямоугольников вокруг лиц на изображении. В этом разделе мы немного изменим код, чтобы извлечь обнаруженные лица из изображения в отдельные файлы.

Откройте app.py в текстовом редакторе:

Затем добавьте выделенные строки после строки cv2.rectangle:

.
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
roi_color = image[y:y + h, x:x + w]

print(«[INFO] Object found. Saving locally.»)

cv2.imwrite(str(w) + str(h) + ‘_faces.jpg’, roi_color)
.

Объект roi_color отображает расположения пикселей в списке лиц на исходном входном изображении. Переменные x, y, h и w являются расположениями в пикселях для каждого объекта, обнаруженного методом faceCascade.detectMultiScale. Затем код возвращает вывод о том, что объект был найден и будет сохранен локально.

Как только это будет сделано, код сохранит найденный объект как новое изображение, используя метод cv2.imwrite. Он добавляет к имени изображения ширину и высоту объекта. Это позволит получить уникальное имя файла (если лиц на фото несколько).

Обновленный скрипт app.py будет выглядеть так:

import cv2
import sys
imagePath = sys.argv[1]
image = cv2.imread(imagePath)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
faceCascade = cv2.CascadeClassifier(cv2.data.haarcascades + «haarcascade_frontalface_default.xml»)
faces = faceCascade.detectMultiScale(
gray,
scaleFactor=1.3,
minNeighbors=3,
minSize=(30, 30)
)
print(«[INFO] Found <0>Faces.».format(len(faces)))
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
roi_color = image[y:y + h, x:x + w]
print(«[INFO] Object found. Saving locally.»)
cv2.imwrite(str(w) + str(h) + ‘_faces.jpg’, roi_color)
status = cv2.imwrite(‘faces_detected.jpg’, image)
print(«[INFO] Image faces_detected.jpg written to filesystem: «, status)

Обновленный код использует расположения пикселей, чтобы извлечь лица из изображения в новый файл. Сохраните и закройте файл.

Теперь, когда вы обновили код, можете запустить скрипт еще раз:

python app.py path/to/image

Вы увидите примерно такой результат, как только ваш скрипт завершит обработку изображения:

[INFO] Found 4 Faces.
[INFO] Object found. Saving locally.
[INFO] Object found. Saving locally.
[INFO] Object found. Saving locally.
[INFO] Object found. Saving locally.
[INFO] Image faces_detected.jpg written to file-system: True

В зависимости от количества лиц на вашем изображении вывод будет больше или меньше.

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

Теперь ваш скрипт может извлекать обнаруженные объекты из входного изображения и сохранять их локально.

Заключение

В данном мануале вы научились писать сценарии OpenCV и Python для обнаружения, подсчета и извлечения лиц из входного изображения. Вы можете расширить этот скрипт для поиска разных объектов с помощью других предварительно обученных каскадов Хаара из библиотеки OpenCV или научиться обучать свой собственный каскад.

Распознаем лица на фото с помощью Python и OpenCV

В этой статье я хотел бы остановиться на алгоритмах распознавания лиц, а заодно познакомить вас с очень интересной и полезной библиотекой OpenCV. Уверен, что этот материал окажется полезным для новичков в этой области.

Что нам понадобится:
• Установленный Python 2.7 с библиотеками NumPy и PIL
• OpenCV 2-й версии

Здесь ссылка на материал по установке всех необходимых компонентов. Установка всего необходимого не составит труда.

Для начала давайте разберемся, как распознать лицо на фотографии. Во-первых, нужно найти, где на фото расположено лицо человека и не спутать его с часами на стене и кактусом на подоконнике. Казалось бы, простая задача для человека, оказывается не такой простой для компьютера. Для того, чтобы найти лицо мы должны выделить его основные компоненты, такие как нос, лоб, глаза, губы и т.д. Для этого будем использовать шаблоны (они же примитивы Хаара) на подобие таких:

Если шаблоны соответствуют конкретным областям на изображении, будем считать, что на изображении есть человеческое лицо. На самом деле подобных шаблонов гораздо больше. Для каждого из них считается разность между яркостью белой и черной областей. Это значение сравнивается с эталоном и принимается решение о том, есть ли здесь часть человеческого лица или нет.
Этот метод называется методом Виолы-Джонса (так же известен как каскады Хаара). Давайте представим, что у нас на фотографии не одно большое лицо, а много мелких. Если применить шаблоны ко всей картинке мы не найдем там лиц, т.к. они будут меньше шаблонов. Для того чтобы искать на всем фото лица разных размеров используется метод скользящего окна. Именно внутри этого окна и высчитываются примитивы. Окно как бы скользит по всему изображению. После каждого прохождения изображения окно увеличивается, чтобы найти лица большего масштаба.

Наглядно демонстрацию алгоритма можно посмотреть на этом видео:

И так мы нашли лицо на фотографии, но как определить, что это лицо именно того кого мы ищем? Для решения этой задачи будем использовать алгоритм Local Binary Patterns. Суть его заключается в том, что мы разбиваем изображение на части и в каждой такой части каждый пиксель сравнивается с соседними 8 пикселями. Если значение центрального пикселя больше соседнего, то пишем 0, в противном случае 1. И так для каждого пикселя у нас получается некоторое число. Далее на основе этих чисел для всех частей, на которые мы разбивали фотографию, считается гистограмма. Все гистограммы со всех частей объединяются в один вектор характеризующий изображение в целом. Если мы хотим узнать насколько похожи два лица, нам придется вычислить для каждого из них такой вектор и сравнить их. Рисунки ниже помогут лучше понять суть алгоритма:

Ну хорошо, давайте, наконец напишем немного кода. За основу я взял код из этой статьи.

Параметр cascadePath содержит имя файла с уже готовыми значениями для распознавания лиц. Этот файл можно взять из директории с OpenCV (opencvbuildetchaarcascades).
Далее создаем объект CascadeClassifier и объект распознавания лиц LBPHFaceRecognizer. На последнем остановимся поподробнее, точнее, на его параметрах. Первые два значения 1 и 8 характеризуют окрестности пикселя. Наглядно, что это такое можно продемонстрировать этой картинкой:

То есть первое число это радиус в котором мы выбираем пиксели, а второй число этих пикселей. Чем больше пикселей в окрестности точки мы возьмем, тем точнее будет наше распознавание.
Следующие параметры (8,8) характеризуют размеры областей на которые мы разбиваем исходное изображение с лицом. Чем оно меньше, тем больше будет таких областей и тем качественнее распознавание.
И наконец, последнее значение это параметр confidence threshold, определяющий пороговое значение для распознавания лица. Чем меньше confidence тем больше алгоритм уверен в том, что на фотографии изображено известное ему лицо. Порог означает, что когда уверенности мало алгоритм просто считает это лицо незнакомым. В данном случае порог равен 123.

Идем дальше. Напишем функцию, которая находит по определенному пути во всех фотографиях лица людей и сохраняет их.

Для примера я использовал БД лиц под названием Yale Faces. В ней есть 15 человек с разными выражениями лиц на каждой фотографии.

Имя каждого файла в этой БД выглядит следующим образом: subject01.sad. Сначала идет слово subject, далее порядковый номер человека, а после характеристика фото. Например, характеристика sad означает грустное лицо, happy веселое и т.п.
Функция get_images считывает каждую фотографию, кроме тех, что с окончанием .happy и выделяет ту область, где находится лицо. Фотографии с веселым выражением лица будем использовать на следующем шаге для распознавания, это будет контрольная выборка, т.е. те фото на которых мы будем проверять качество распознавания.
Так же из каждого названия файла извлекается номер человека на фотографии и сохраняется список labels. Каждой фотографии в итоге будет сопоставлен этот номер.
Функция faceCascade.detectMultiScale() определяет области на фотографии, где есть человеческие
лица. Она возвращает список с параметрами [x,y,w,h] для каждого найденного лица. Эти
параметры описывают прямоугольную область в том месте, где нашлось лицо.

Теперь давайте разберемся с параметрами функции:
image – исходное изображение
scaleFactor – определяет то, на сколько будет увеличиваться скользящее окно поиска на каждой итерации. 1.1 означает на 10%, 1.05 на 5% и т.д. Чем больше это значение, тем быстрее работает алгоритм.
minNeighbors — Чем больше это значение, тем более параноидальным будет поиск и тем чаще он будет пропускать реальные лица, считая, что это ложное срабатывание. Оптимальное значение 3-6.
minSize – минимальный размер лица на фото. 30 на 30 обычно вполне достаточно.

Ну что же, теперь мы можем создать набор лиц и соответствующих им меток. Давайте научим программу распознавать эти лица.

Указываем путь к нашим фото, получаем список с фотографиями и метками. А дальше запускаем нашу функцию тренировки с помощью алгоритма LBP. Ничего сверхъестественного в ней нет, просто передаем ей значения, полученные после запуска функции get_images(). Все остальное программа сделает сама.
И так у нас есть обученный «распознаватель» и есть набор счастливых лиц. Теперь нам необходимо попросить алгоритм распознать эти счастливые лица.

В цикле опять определяем расположение лица на каждом фото с окончанием .happy. Все параметры и процедуры такие же, как и на предыдущем этапе.
Для каждого найденного лица запускаем функцию recognizer.predict(), возвращающую номер-идентификатор субъекта, который предположительно находится на фото, а так же параметр confidence. Далее сравниваем значение, которое нам вернула функция с реальным номером субъекта, если они равны, распознавание прошло успешно.
Ну, вот и все, дальше в консоль выводятся результаты распознавания для каждой фотографии из контрольной выборки.

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

Пишу программу, которая должна распознавать лица с картинки. Использую библиотеку компьютерного зрения OpenCV и язык программирования Python 2.7.

Для распознавания использую каскады Хаара, которые идут в комплекте с OpenCV, а именно: haarcascade_eye.xml и haarcascade_frontalface_defaul t.xml.

Как, наверное Вы уже догадались, сейчас программа находит только глаза и, собственно, само лицо.
А необходимо, что бы код находил также нос и губы. Но к сожалению, в интернете каскадов этих частей лица я не нашел.

Вопрос: Существуют ли эти каскады вообще, и если да — где их можно взять?
Хотелось бы получить каскады в виде .xml файла, как в примерах OpenCV.

14.10.2017, 18:11

Opencv — распознавание лиц
Я взял код отсюда https://robotos.in/uroki/obnaruzhenie-i-raspoznavanie-litsa-na-python import cv2.

Распознавание лица
Здравствуйте! Необходимо через первую веб-камеру сохранить лицо человека в папку с расширением.

Распознавание лица
есть код распознавания лиц на питоне хочу переписать на с++ но никак не выходит вот код.

Распознавание лица человека
Здравствуйте! Имеется программа на С#, которая через первую веб-камеру сохраняет лицо человека в.

15.10.2017, 00:18 2 23.10.2017, 02:56 3 26.10.2017, 00:06 [ТС] 4

Добавлено через 2 минуты
Если не сложно, пржалуйсто дайте исходники вашей реализации, хотелось бы посмотреть что там да как.
А насчёт обученных каскадов: Как их можно объявить, как они вообще выглядят? Как .xml файлы? Как ими пользоваться.
И ещё, я OpenCV не компилировал, а качал .pyd файл с официального репозитория, эти каскады будут работать?

29.10.2017, 21:55 5

Решение

Этот подход давно устарел. Его создали в 2000-ых годах. Возможно, в начале 2000-ых. За 17 лет алгоритмы ушли далеко вперёд. Используй библиотеку dlib для распознавания лиц, эмоций, губ, ушей, рта и т.д.

Есть и другие современные алгоритмы, которые не хуже dlib, но haarcascade_frontalface_defaul t.xml — это очень древние вещи.

Я их раньше использовал. Очень много ложных срабатываний. Для фана годятся, но не более. Библиотеке dlib более стабильна в этом плане.

29.10.2017, 23:26 [ТС] 6 30.10.2017, 00:11 7

Я не знаю, какая у вас операционная система, но в компьютерном зрении стандарт — Linux. Так как у меня тоже Linux, то расскажу, как установить dlib на Ubuntu
Сначала нужно установить необходимые библиотеки: открывает терминал и пишем следующие команды

sudo apt-get install build-essential cmake
sudo apt-get install libgtk-3-dev
sudo apt-get install libboost-all-dev
wget https://bootstrap.pypa.io/get-pip.py
sudo python get-pip.py
pip3 install numpy
pip3 install scipy
pip3 install scikit-image

А вот теперь можно установить и сам dlib

pip3 install dlib

Чтобы убедиться, что dlib установлен верно, нужно открыть терминал, а затем набрать
python3
import dlib

Если ошибки не будет, то всё установлено верно.

30.10.2017, 12:04 [ТС] 8 30.10.2017, 15:11 9

У меня нет под рукой Windows, поэтому я не могу проверить свои слова, установив dlib туда. Я могу лишь сказать, что для правильной работы dlib нужно иметь библиотеки:
Boost, Boost.Python, CMake, X11/XQuartx, numpy, scipy, scikit-image

Вот, например, можно найти установку boost для 32-ти битной версии windows 7 https://boost.teeks99.com/bin/1.62.0/

Здесь можно установить CMAKE для WIndows: https://cmake.org/download/

Вроде бы в WIndows 7 есть pip, поэтому можно дальше написать (в командной строке)
pip install numpy
pip install scipy
pip install scikit-image

И можно устанавливать dlib. Но здесь есть одна тонкость. Так как ты используешь WIndws 7 32, то, вероятно, у тебя крайне древний процессор, поэтому вариант pip install dlib не прокатит, так как по умолчанию будет идти поддержка SSE4 инструкций, которые не поддерживает твой древний процессор.

Распаковать, зайти в tools/python/CMakeLists.txt и заменить следующую строчку:
set(USE_SSE4_INSTRUCTIONS ON CACHE BOOL «Use SSE4 instructions»)

set(USE_SSE2_INSTRUCTIONS ON CACHE BOOL «Use SSE2 instructions»)

Потом запустить командную строку, возможно, с правами администратора, перейти в распакованную папку и запустить
python3 setup.py install

Так должно работать, но у меня нет под рукой WIndows 7 32 бит, чтобы это проверить. Это лишь мои догадки.