Главная > Микроволновки > Распознавание контура тела в реальном времени. Распознавание образов с OpenCV: Контуры против Haartraining


Распознавание контура тела в реальном времени. Распознавание образов с OpenCV: Контуры против Haartraining




При решении задач компьютерного зрения не обойтись без использования специализированного софта. Хочу познакомить вас с таким - OpenCV - библиотека с открытым исходном кодом на C++. Обладает набором инструментов для оцифровки изображений, последующей обработки через численные алгоритмы или нейросеть.

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

Скачать библиотеку можно на официальном сайте http://sourceforge.net/projects/opencvlibrary/

Структура библиотеки OpenCV

cxcore - ядро
* содержит базовые структуры данных и алгоритмы:
- базовые операции над многомерными числовыми массивами
- матричная алгебра, математические ф-ции, генераторы случайных чисел
- Запись/восстановление структур данных в/из XML
- базовые функции 2D графики

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

Highgui - модуль для ввода/вывода изображений и видео, создания пользовательского интерфейса
- захват видео с камер и из видео файлов, чтение/запись статических изображений.
- функции для организации простого UI (все демо приложения используют HighGUI)

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

CvCam - захват видео
- позволяет осуществлять захват видео с цифровых видео-камер (поддержка прекращена и в последних версиях этот модуль отсутствует)


Установка OpenCV под Linux

После скачивания последней версии OpenCV с сайта разработчика http://sourceforge.net/projects/opencvlibrary/ нужно распаковать архив и выполнить сборку через CMake версии 2.6 или выше.

Установка CMake выполняется стандартно:

Sudo apt-get install cmake

Для отображения окон OpenCV потребуется установить библиотеки GTK+ 2.x и libgtk2.0-dev

Apt-get install libgtk2.0-dev

Собираем библиотеку:

Tar -xjf OpenCV-2.2.0.tar.bz2 cd OpenCV-2.2.0 cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local ./ make make install

Для тестирования установленной библиотеки можно собрать примеры и что-нибудь запустить:

Cd samples/c/ chmod +x build_all.sh ./build_all.sh ./delaunay

Если вместо тестовой картинки вы увидите ошибку "error while loading shared libraries: libopencv_core.so.2.2: cannot open shared object file: No such file or directory", то это значит, что программа не может найти библиотеки. Нужно явно указать путь до них:

$ export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH

Если после этого опять ошибка:
OpenCV Error: Unspecified error (The function is not implemented. Rebuild the library with Windows, GTK+ 2.x or Carbon support. If you are on Ubuntu or Debian, install libgtk2.0-dev and pkg-config, then re-run cmake or configure script) in cvNamedWindow, file /usr/src/OpenCV-2.2.0/modules/highgui/src/window.cpp, line 274 terminate called after throwing an instance of "cv::Exception" what(): /usr/src/OpenCV-2.2.0/modules/highgui/src/window.cpp:274: error: (-2) The function is not implemented. Rebuild the library with Windows, GTK+ 2.x or Carbon support. If you are on Ubuntu or Debian, install libgtk2.0-dev and pkg-config, then re-run cmake or configure script in function cvNamedWindow
Значит вы забыли установить GTK+ 2.x: libgtk2.0-dev. Запустите установку (см. выше).

Когда установка завершена заголовочные файлы будут доступны в дирректории /usr/local/include/opencv , а библиотечные файлы лежат в /usr/local/lib

Соберем программу с OpenCV:

test.cpp

// // for testing // // robocraft.ru // #include #include #include #include int main(int argc, char* argv) { IplImage* image=0, *dst=0; // имя картинки char filename = "Image0.jpg"; // получаем картинку image = cvLoadImage(filename, 1); printf("[i] image: %s\n", filename); assert(image != 0); // покажем изображение cvNamedWindow("image"); cvShowImage("image", image); // ждём нажатия клавиши cvWaitKey(0); // освобождаем ресурсы cvReleaseImage(& image); cvReleaseImage(&dst); // удаляем окна cvDestroyAllWindows(); return 0; }

Makefile

CC:= g++ CFLAGS:= -I/usr/local/include/opencv -L/usr/local/lib OBJECTS:= LIBRARIES:= -lopencv_core -lopencv_imgproc -lopencv_highgui .PHONY: all clean all: test test: $(CC) $(CFLAGS) -o test test.cpp $(LIBRARIES) clean: rm -f *.o

Запуск сборки коммандой make.


Hello World!

OpenCV установлен и готов к работе. Напишем свое первое приложение Hello World!

#include #include int main(int argc, char** argv) { // задаём высоту и ширину картинки int height = 620; int width = 440; // задаём точку для вывода текста CvPoint pt = cvPoint(height/4, width/2); // Создаёи 8-битную, 3-канальную картинку IplImage* hw = cvCreateImage(cvSize(height, width), 8, 3); // заливаем картинку чёрным цветом cvSet(hw,cvScalar(0,0,0)); // инициализация шрифта CvFont font; cvInitFont(&font, CV_FONT_HERSHEY_COMPLEX,1.0, 1.0, 0, 1, CV_AA); // используя шрифт выводим на картинку текст cvPutText(hw, "OpenCV Step By Step", pt, &font, CV_RGB(150, 0, 150)); // создаём окошко cvNamedWindow("Hello World", 0); // показываем картинку в созданном окне cvShowImage("Hello World", hw); // ждём нажатия клавиши cvWaitKey(0); // освобождаем ресурсы cvReleaseImage(&hw); cvDestroyWindow("Hello World"); return 0; }

Загрузка изображения

Данный пример будет основой всех ваших программ на OpenCV. Мы загрузим в среду изображение из файла Image0.jpg

#include #include #include #include IplImage* image = 0; IplImage* src = 0; int main(int argc, char* argv) { // имя картинки задаётся первым параметром char* filename = argc == 2 ? argv : "Image0.jpg"; // получаем картинку image = cvLoadImage(filename,1); // клонируем картинку src = cvCloneImage(image); printf("[i] image: %s\n", filename); assert(src != 0); // окно для отображения картинки cvNamedWindow("original",CV_WINDOW_AUTOSIZE); // показываем картинку cvShowImage("original",image); // выводим в консоль информацию о картинке printf("[i] channels: %d\n", image->nChannels); printf("[i] pixel depth: %d bits\n", image->depth); printf("[i] width: %d pixels\n", image->width); printf("[i] height: %d pixels\n", image->height); printf("[i] image size: %d bytes\n", image->imageSize); printf("[i] width step: %d bytes\n", image->widthStep); // ждём нажатия клавиши cvWaitKey(0); // освобождаем ресурсы cvReleaseImage(& image); cvReleaseImage(&src); // удаляем окно cvDestroyWindow("original"); return 0; }

Поддерживаемые типы форматов изображений:

  • Windows bitmaps - BMP, DIB
  • JPEG files - JPEG, JPG, JPE
  • Portable Network Graphics - PNG
  • Portable image format - PBM, PGM, PPM
  • Sun rasters - SR, RAS
  • TIFF files - TIFF, TIF

Для обращения к изображению можно делать такие вызовы:

Image->nChannels // число каналов картинки (RGB, хотя в OpenCV - BGR) (1-4) image->depth // глубина в битах image->width // ширина картинки в пикселях image->height // высота картинки в пикселях image->imageSize // память занимаемая картинкой (==image->height*image->widthStep) image->widthStep // расстояние между соседними по вертикали точками изображения (число байт в одной строчке картинки - может потребоваться для самостоятельного обхода всех пикселей изображения)

Загрузка видео

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

#include #include #include #include IplImage* frame =0; int main(int argc, char* argv) { // имя файла задаётся первым параметром char* filename = argc == 2 ? argv : "test.avi"; printf("[i] file: %s\n", filename); // окно для отображения картинки cvNamedWindow("original",CV_WINDOW_AUTOSIZE); // получаем информацию о видео-файле CvCapture* capture = cvCreateFileCapture(filename); while(1){ // получаем следующий кадр frame = cvQueryFrame(capture); if(!frame) { break; } // здесь можно вставить // процедуру обработки // показываем кадр cvShowImage("original", frame); char c = cvWaitKey(33); if (c == 27) { // если нажата ESC - выходим break; } } // освобождаем ресурсы cvReleaseCapture(&capture); // удаляем окно cvDestroyWindow("original"); return 0; }

Для захвата видео с камеры нужно немного модифицировать код - вместо функции cvCreateFileCapture() будет использоваться cvCreateCameraCapture(). При нажатии ESC воспроизведение прервется и окно закроется, а при нажатии Enter текущий кадр сохранится в jpg файл.

#include #include #include #include int main(int argc, char* argv) { // получаем любую подключённую камеру CvCapture* capture = cvCreateCameraCapture(CV_CAP_ANY); //cvCaptureFromCAM(0); assert(capture); //cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, 640);//1280); //cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, 480);//960); // узнаем ширину и высоту кадра double width = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH); double height = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT); printf("[i] %.0f x %.0f\n", width, height); IplImage* frame=0; cvNamedWindow("capture", CV_WINDOW_AUTOSIZE); printf("[i] press Enter for capture image and Esc for quit!\n\n"); int counter=0; char filename; while(true){ // получаем кадр frame = cvQueryFrame(capture); // показываем cvShowImage("capture", frame); char c = cvWaitKey(33); if (c == 27) { // нажата ESC break; } else if(c == 13) { // Enter // сохраняем кадр в файл sprintf(filename, "Image%d.jpg", counter); printf("[i] capture... %s\n", filename); cvSaveImage(filename, frame); counter++; } } // освобождаем ресурсы cvReleaseCapture(&capture); cvDestroyWindow("capture"); return 0; }

OpenCV v1.0 показывает и сохраняет картинку минимального разрешения камеры 320x240.


Распознавание объектов по шаблону

Для распознавание областей на исходном изображении по шаблону существует функция cvMatchTemplate(). Функция накладывает шаблон изображения на текущее изображение и согласно выбранному алгоритму выполняет поиск корреляции между ними. Определение границ найденного шаблона на исходном изображении выполняется функцией cvMinMaxLoc, а для нормализации алгоритма поиска cvNormalize().

// // пример cvMatchTemplate() // сравнение изображение с шаблоном // #include #include #include #include IplImage* image = 0; IplImage* templ = 0; int main(int argc, char* argv) { // имя картинки задаётся первым параметром char* filename = argc >= 2 ? argv : "Image0.jpg"; // получаем картинку image = cvLoadImage(filename,1); printf("[i] image: %s\n", filename); assert(image != 0); // шаблон char* filename2 = argc >= 3 ? argv : "eye.jpg"; printf("[i] template: %s\n", filename2); templ = cvLoadImage(filename2,1); assert(templ != 0); cvNamedWindow("origianl", CV_WINDOW_AUTOSIZE); cvNamedWindow("template", CV_WINDOW_AUTOSIZE); cvNamedWindow("Match", CV_WINDOW_AUTOSIZE); cvNamedWindow("res", CV_WINDOW_AUTOSIZE); // размер шаблона int width = templ->width; int height = templ->height; // оригинал и шаблон cvShowImage("origianl", image); cvShowImage("template", templ); // изображение для хранения результата сравнения // размер результата: если image WxH и templ wxh, то result = (W-w+1)x(H-h+1) IplImage *res = cvCreateImage(cvSize((image->width-templ->width+1), (image->height-templ->height+1)), IPL_DEPTH_32F, 1); // сравнение изображения с шаблоном cvMatchTemplate(image, templ, res, CV_TM_SQDIFF); // покажем что получили cvShowImage("res", res); // определение лучшее положение для сравнения // (поиск минимумов и максимумов на изображении) double minval, maxval; CvPoint minloc, maxloc; cvMinMaxLoc(res, &minval, &maxval, &minloc, &maxloc, 0); // нормализуем cvNormalize(res,res,1,0,CV_MINMAX); cvNamedWindow("res norm", CV_WINDOW_AUTOSIZE); cvShowImage("res norm", res); // выделим область прямоугольником cvRectangle(image, cvPoint(minloc.x, minloc.y), cvPoint(minloc.x+templ->width-1, minloc.y+templ->height-1), CV_RGB(255, 0, 0), 1, 8); // показываем изображение cvShowImage("Match", image); // ждём нажатия клавиши cvWaitKey(0); // освобождаем ресурсы cvReleaseImage(&image); cvReleaseImage(&templ); cvReleaseImage(&res); cvDestroyAllWindows(); return 0; }

В этой статье использован C++ интерфейс, FREAK и детектирование множества объектов. Надежность детектирования объектов с помощью FREAK ниже, чем SURF, однако его работа намного быстрее, что позволяет использовать алгоритм на мобильных и встроенных системах. Пример работы представлен на рисунке:

Рассмотрим исходный код, который позволяет этого достигнуть. Код приведен полностью для желающих быстро вставить его в свой проект.
#include #include #include #include #include #include #include #include keypointsImageTemple, keypointsImage; Mat descriptorsImageTemple, descriptorsImage; std::vector matches; // Инициалищация класса детектора особенностей, 1000 - пороговое значение для отсеивания // малозначимых особенностей SurfFeatureDetector detector(1000); // Класс для FREAK особенностей. Можно настраивать режимы сравнения особенностей: // FREAK extractor(true, true, 22, 4, std::vector matcher; // Детектирование double t = (double)getTickCount(); detector.detect(ImageTemple, keypointsImageTemple); detector.detect(Image, keypointsImage); t = ((double)getTickCount() - t)/getTickFrequency(); std::cout << "detection time [s]: " << t/1.0 << std::endl; // Извлечение особенностей t = (double)getTickCount(); extractor.compute(ImageTemple, keypointsImageTemple, descriptorsImageTemple); extractor.compute(Image, keypointsImage, descriptorsImage); t = ((double)getTickCount() - t)/getTickFrequency(); std::cout << "extraction time [s]: " << t << std::endl; // Сравнение t = (double)getTickCount(); matcher.match(descriptorsImageTemple, descriptorsImage, matches); t = ((double)getTickCount() - t)/getTickFrequency(); std::cout << "matching time [s]: " << t << std::endl; // Отобразить на изображении Mat imgMatch; drawMatches(ImageTemple, keypointsImageTemple, Image, keypointsImage, matches, imgMatch); imwrite("matches.jpeg", imgMatch); std::vectorObj; std::vectorScene; for(int i = 0; i < matches.size(); i++) { obj.push_back(keypointsImageTemple[ matches[i].queryIdx ].pt); scene.push_back(keypointsImage[ matches[i].trainIdx ].pt); } Mat H = findHomography(obj, scene, CV_RANSAC); std::vector Scene_corners(4); perspectiveTransform(obj_corners, scene_corners, H); //-- Draw lines between the corners (the mapped object in the scene - image_2) line(imgMatch, scene_corners + Point2f(ImageTemple.cols, 0), scene_corners + Point2f(ImageTemple.cols, 0), Scalar(0, 255, 0), 4); line(imgMatch, scene_corners + Point2f(ImageTemple.cols, 0), scene_corners + Point2f(ImageTemple.cols, 0), Scalar(0, 255, 0), 4); line(imgMatch, scene_corners + Point2f(ImageTemple.cols, 0), scene_corners + Point2f(ImageTemple.cols, 0), Scalar(0, 255, 0), 4); line(imgMatch, scene_corners + Point2f(ImageTemple.cols, 0), scene_corners + Point2f(ImageTemple.cols, 0), Scalar(0, 255, 0), 4); imwrite("matches3.jpeg", imgMatch); return 0; }

Для любых особенностей в OpenCV необходимо инициализировать класс SurfFeatureDetector. Первое действие после различных инициализаций – это детектирование особенностей detector.detect для эталонного изображения и изображения сцены. После чего для каждого изображения по результатам работы детектора вычисляются FREAK особенности: extractor.compute.
Сравнение схожести особенностей осуществляется с помощью matcher.match.
Далее присутствует цикл с формированием точек из особенностей для обоих изображений. На основании точек вычисляется гомография изображений findHomography. Положение и поворот объекта вычисляется с помощью функции perspectiveTransform. Ну а затем – вывод на изображение.
Эталонное изображение:

Изображение сцены:


Результат представлен вначале.
Однако здесь возникает вопрос, как рассчитывать оптимальный порог особенностей: SurfFeatureDetector detector(1000);. Ответ – экспериментально. Некоторую информацию по данному вопросу вы можете получить .
Предположим, что у нас на изображении несколько объектов:


Результат работы программы будет следующий:


Естественно, что такая ситуация не устраивает. Для того, чтобы детектировать все объекты, необходимо разделить изображение на несколько частей. Однако здесь следует помнить, что если изображение разделить на непересекающиеся блоки (пример изображение 100x100 разделить на 4 блока по 50x50), то может возникнуть ситуация, когда объект будет частично находиться в нескольких блоках и не будет детектирован. Для избегания этого необходимо делать пересекающиеся блоки, что несколько замедлит работу, но улучшит качество (пример изображение 100x100 разделить на 9 блоков по 50x50 так, как показано в примере). Пример программы детектирующий множество объектов ниже:
#include #include #include #include #include #include #include #include using namespace cv; int main(int argc, char** argv) { if(argc != 3) return 1; Mat ImageTemple = imread(argv, CV_LOAD_IMAGE_GRAYSCALE); if(!ImageTemple.data) return 2; // Ошибка Mat Image = imread(argv, CV_LOAD_IMAGE_GRAYSCALE); if(!Image.data) return 3; // Ошибка std::vector keypointsImageTemple; Mat descriptorsImageTemple; std::vector matches; // Инициалищация класса детектора особенностей, 1000 - пороговое значение для отсеивания // малозначимых особенностей SurfFeatureDetector detector(1000); detector.detect(ImageTemple, keypointsImageTemple); int maxy = 3; int maxx = 3; Mat Draw_mat = imread(argv, 1); for(int y = 0; y < maxy; y++) for(int x = 0; x < maxx; x++) { // Класс для FREAK особенностей. Можно настраивать режимы сравнения особенностей: // FREAK extractor(true, true, 22, 4, std::vector()); FREAK extractor; // Используется для определение совпадений особенностей - мера Хемминга BruteForceMatcher matcher; std::vector keypointsImage; Mat descriptorsImage; CvRect Rect = cvRect(x * (Image.cols / (maxx + 1)), y * (Image.rows / (maxy + 1)), 2 * (Image.cols / (maxx + 1)), 2 * (Image.rows / (maxy + 1))); Mat ImageROI(Image, Rect); detector.detect(ImageROI, keypointsImage); extractor.compute(ImageTemple, keypointsImageTemple, descriptorsImageTemple); extractor.compute(ImageROI, keypointsImage, descriptorsImage); matcher.match(descriptorsImageTemple, descriptorsImage, matches); // Отброс слишком расходящихся значений for (int i = 0; i < matches.size(); i++) { if(matches[i].distance > 150) { matches.erase (matches.begin() + i); } } std::vectorObj; std::vectorScene; for(int i = 0; i < matches.size(); i++) { obj.push_back(keypointsImageTemple[ matches[i].queryIdx ].pt); scene.push_back(keypointsImage[ matches[i].trainIdx ].pt); } Mat H = findHomography(obj, scene, CV_RANSAC); std::vectorObj_corners(4); obj_corners = cvPoint(0,0); obj_corners = cvPoint(ImageTemple.cols, 0); obj_corners = cvPoint(ImageTemple.cols, ImageTemple.rows); obj_corners = cvPoint(0, ImageTemple.rows); std::vectorScene_corners(4); perspectiveTransform(obj_corners, scene_corners, H); //-- Draw lines between the corners (the mapped object in the scene - image_2) line(Draw_mat, scene_corners + Point2f(x * (Image.cols / (maxx + 1)), y * (Image.rows / (maxy + 1))), scene_corners + Point2f(x * (Image.cols / (maxx + 1)), y * (Image.rows / (maxy + 1))), Scalar(0, 255, 0), 4); line(Draw_mat, scene_corners + Point2f(x * (Image.cols / (maxx + 1)), y * (Image.rows / (maxy + 1))), scene_corners + Point2f(x * (Image.cols / (maxx + 1)), y * (Image.rows / (maxy + 1))), Scalar(0, 255, 0), 4); line(Draw_mat, scene_corners + Point2f(x * (Image.cols / (maxx + 1)), y * (Image.rows / (maxy + 1))), scene_corners + Point2f(x * (Image.cols / (maxx + 1)), y * (Image.rows / (maxy + 1))), Scalar(0, 255, 0), 4); line(Draw_mat, scene_corners + Point2f(x * (Image.cols / (maxx + 1)), y * (Image.rows / (maxy + 1))), scene_corners + Point2f(x * (Image.cols / (maxx + 1)), y * (Image.rows / (maxy + 1))), Scalar(0, 255, 0), 4); } imwrite("draw_mat.jpeg", Draw_mat); return 0; }

Результат работы следующий:


Видно, что все объекты детектированы. Причем некоторые дважды (из-за того, что попали в два блока).

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

Установка

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

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

import cv2 image = cv2.imread("./путь/к/изображению.расширение") cv2.imshow("Image", image) cv2.waitKey(0) cv2.destroyAllWindows()

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

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

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

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

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

Import cv2 def viewImage(image, name_of_window): cv2.namedWindow(name_of_window, cv2.WINDOW_NORMAL) cv2.imshow(name_of_window, image) cv2.waitKey(0) cv2.destroyAllWindows()

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

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

Import cv2 cropped = image viewImage(cropped, "Пёсик после кадрирования")

Где image - это image .

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

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

Import cv2 scale_percent = 20 # Процент от изначального размера width = int(img.shape * scale_percent / 100) height = int(img.shape * scale_percent / 100) dim = (width, height) resized = cv2.resize(img, dim, interpolation = cv2.INTER_AREA) viewImage(resized, "После изменения размера на 20 %")

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

Поворот

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

Import cv2 (h, w, d) = image.shape center = (w // 2, h // 2) M = cv2.getRotationMatrix2D(center, 180, 1.0) rotated = cv2.warpAffine(image, M, (w, h)) viewImage(rotated, "Пёсик после поворота на 180 градусов")

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

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

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

Чёрно-белый пёсик

Import cv2 gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) ret, threshold_image = cv2.threshold(im, 127, 255, 0) viewImage(gray_image, "Пёсик в градациях серого") viewImage(threshold_image, "Чёрно-белый пёсик")

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

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

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

Ret, threshold = cv2.threshold(im, 150, 200, 10)

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

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

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

Размытый пёсик

Import cv2 blurred = cv2.GaussianBlur(image, (51, 51), 0) viewImage(blurred, "Размытый пёсик")

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

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

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

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

Import cv2 output = image.copy() cv2.rectangle(output, (2600, 800), (4100, 2400), (0, 255, 255), 10) viewImage(output, "Обводим прямоугольником лицо пёсика")

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

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

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

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

Import cv2 output = image.copy() cv2.line(output, (60, 20), (400, 200), (0, 0, 255), 5) viewImage(output, "2 пёсика, разделённые линией")

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

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

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

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

Import cv2 output = image.copy() cv2.putText(output, "We <3 Dogs", (1500, 3600),cv2.FONT_HERSHEY_SIMPLEX, 15, (30, 105, 210), 40) viewImage(output, "Изображение с текстом")

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

  1. Непосредственно изображение.
  2. Текст для изображения.
  3. Координата нижнего левого угла начала текста (x, y) .

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

    Import cv2 image_path = "./путь/к/фото.расширение" face_cascade = cv2.CascadeClassifier("haarcascade_frontalface_default.xml") image = cv2.imread(image_path) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, scaleFactor= 1.1, minNeighbors= 5, minSize=(10, 10)) faces_detected = "Лиц обнаружено: " + format(len(faces)) print(faces_detected) # Рисуем квадраты вокруг лиц for (x, y, w, h) in faces: cv2.rectangle(image, (x, y), (x+w, y+h), (255, 255, 0), 2) viewImage(image,faces_detected)

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

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

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

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

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

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

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

    import cv2 image = cv2.imread("./импорт/путь.расширение") cv2.imwrite("./экспорт/путь.расширение", image)

    Заключение

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

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

Из этой статьи вы узнаете, как создать Python-скрипт для подсчёта количества книг на изображении с помощью OpenCV .

Что мы будем делать?

Взглянем на изображение, на котором будем искать книги:

Мы видим, что на изображении находятся четыре книги, а также отвлекающие вещи, такие как кружка кофе, чашка Starbucks, несколько магнитов и конфета.

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

Какие библиотеки нам понадобятся?

Чтобы написать систему для поиска и обнаружения книг на изображениях, мы будем использовать OpenCV для работы с компьютерным зрением и обработки изображений. Нам также необходимо установить NumPy для корректной работы OpenCV. Убедитесь, что у вас установлены эти библиотеки!

Поиск книг на изображениях с помощью Python и OpenCV

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

Откройте свой любимый редактор кода, создайте новый файл с именем find_books.py и начнем:

# -*- coding: utf-8 -*- # импортируйте необходимые пакеты import numpy as np import cv2 # загрузите изображение, смените цвет на оттенки серого и уменьшите резкость image = cv2.imread("example.jpg") gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) gray = cv2.GaussianBlur(gray, (3, 3), 0) cv2.imwrite("gray.jpg", gray)

Начнем с импорта библиотеки OpenCV. Загрузка изображения с диска обрабатывается функцией cv2.imread . Здесь мы просто загружаем его с диска, а затем преобразуем цветовую гамму из RGB в оттенки серого.

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

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

Теперь давайте определим края (т.е. контуры) объектов на изображении:

# распознавание контуров edged = cv2.Canny(gray, 10, 250) cv2.imwrite("edged.jpg", edged)

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

Мы нашли контуры объектов на изображениях. Однако, как вы видите, некоторые из контуров не закрыты - между контурами существуют промежутки. Чтобы убрать промежутки между белыми пикселями изображения, мы применим операцию «закрытия»:

# создайте и примените закрытие kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (7, 7)) closed = cv2.morphologyEx(edged, cv2.MORPH_CLOSE, kernel) cv2.imwrite("closed.jpg", closed)

Теперь пробелы в контурах закрыты:

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

# найдите контуры в изображении и подсчитайте количество книг cnts = cv2.findContours(closed.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) total = 0

Рассмотрим геометрию книги.

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

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

# цикл по контурам for c in cnts: # аппроксимируем (сглаживаем) контур peri = cv2.arcLength(c, True) approx = cv2.approxPolyDP(c, 0.02 * peri, True) # если у контура 4 вершины, предполагаем, что это книга if len(approx) == 4: cv2.drawContours(image, , -1, (0, 255, 0), 4) total += 1

Для каждого из контуров мы вычисляем периметр, используя cv2.arcLength , а затем аппроксимируем (сглаживаем) контур, используя cv2.approxPolyDP .

Причина, по которой мы аппроксимируем контур, заключается в том, что он может не быть идеальным прямоугольником. Из-за зашумления и теней на фото вероятность того, что у книги будет ровно 4 вершины, невелика. Аппроксимируя контур, мы решаем эту проблему.

Наконец, мы проверяем, что у аппроксимируемого контура действительно четыре вершины. Если это так, то мы рисуем контур вокруг книги, а затем увеличиваем счётчик общего количества книг.

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

# показываем результирующее изображение print("Я нашёл {0} книг на этой картинке".format(total) cv2.imwrite("output.jpg", image))

На данном этапе наше изображение будет выглядеть так:

Подведем итоги

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

Наш подход состоял в том, чтобы:

  1. Загрузить изображение с диска и преобразовать его в оттенки серого.
  2. Немного размыть изображение.
  3. Применить детектор контуров Canny для обнаружения объектов на изображении.
  4. Закрыть любые промежутки в контурах.
  5. Найти контуры объектов на изображении.
  6. Применить контурную аппроксимацию, чтобы определить, был ли контур прямоугольником и, следовательно, книгой.

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

Основная идея заключается в учете статистических связей между расположением антропометрических точек лица . На каждом изображении лица точки пронумерованы в одинаковом порядке. По их взаимному расположению осуществляется сравнение лиц.

Для сравнения лиц можно использовать одного и того же положения лица относительно камеры. Более предпочтителен для этого .

Захват видеопотока с камеры и выделение лица

#include using namespace cv; int main() { // Load Face cascade (.xml file) CascadeClassifier face_cascade; face_cascade.load("haarcascade_frontalface_alt2.xml"); Mat img; VideoCapture cap(0); while (true) { cap >> img; //cvtColor(img, img, CV_BGR2GRAY); // Detect faces std::vector faces; face_cascade.detectMultiScale(img, faces, 1.1, 2, 0 | CV_HAAR_SCALE_IMAGE, Size(30, 30)); // Draw circles on the detected faces for (int i = 0; i < faces.size(); i++) { Point center(faces[i].x + faces[i].width*0.5, faces[i].y + faces[i].height*0.5); ellipse(img, center, Size(faces[i].width*0.5, faces[i].height*0.5), 0, 0, 360, Scalar(255, 0, 255), 4, 8, 0); } imshow("Detected Face", img); waitKey(1); } return 0; }

Файлы каскадов находятся в директории c:\opencv\build\etc\… Нужный каскад размещаете в директории проекта, там же, где и исходный файл main.cpp.

Выделение особых точек лица

Приложение создано на основе C++ code for OpenCV Facemark

#include #include #include #include #include #include #include "drawLandmarks.hpp" using namespace std; using namespace cv; using namespace cv::face; int main(int argc, char** argv) { // Load Face Detector CascadeClassifier faceDetector("haarcascade_frontalface_alt2.xml"); // Create an instance of Facemark Ptr facemark = FacemarkLBF::create(); // Load landmark detector facemark->loadModel("lbfmodel.yaml"); // Set up webcam for video capture VideoCapture cam(0); // Variable to store a video frame and its grayscale Mat frame, gray; // Read a frame while (cam.read(frame)) { // Find face vector faces; // Convert frame to grayscale because // faceDetector requires grayscale image. cvtColor(frame, gray, COLOR_BGR2GRAY); // Detect faces faceDetector.detectMultiScale(gray, faces); // Variable for landmarks. // Landmarks for one face is a vector of points // There can be more than one face in the image. Hence, we // use a vector of vector of points. vector< vector > landmarks; // Run landmark detector bool success = facemark-> < faces.size(); i++) { cv::rectangle(frame, faces[i], Scalar(0, 255, 0), 3); } for (int i = 0; i < landmarks.size(); i++) { drawLandmarks(frame, landmarks[i]); /*for (size_t j = 0; j < landmarks[i].size(); j++) circle(frame, Point(landmarks[i][j].x, landmarks[i][j].y), 1, Scalar(255, 0, 0), 2);*/ } } // Display results imshow("Facial Landmark Detection", frame); // Exit loop if ESC is pressed if (waitKey(1) == 27) break; } return 0; }

В проекте приложения, там же где и файл main.cpp, разместил файлы haarcascade_frontalface_alt2.xml , drawLandmarks.hpp и lbfmodel.yaml , на которые есть ссылки в коде. Файлы каскадов находятся в директории c:\opencv\build\etc\… Файлы drawLandmarks.hpp и lbfmodel.yaml есть в архиве Facemark_LBF.rar .

После вставки кода появились ошибки из-за того, что в OpenCV 3.4.3-vc14-vc15 отсутствуют ряд библиотек, необходимых для запуска приложения. Скомпоновал свою библиотеку (скачать opencv_new.zip) и установил ее в корень диска C (C:\opencv-new).

Теперь, все настройки, которые выполнялись , необходимо выполнить и для opencv-new:

Выполняю настройки в Windows . Выхожу на окно «Изменить переменную среды» (кнопки Windows->Служебные->Панель управления -> Система и безопасность -> Система -> Дополнительные параметры системы -> Переменные среды -> Path ->Изменить). В этом окне создаю переменную C:\opencv-new \x64\vc14\bin. Перезагружаю Windows .

В свойствах проекта также ссылаюсь на библиотеку opencv_new (вместо opencv). В окне «Property Pages» выполняю действия:

  • C/C++ -> General -> Additional Include Directories -> C:\opencv-new \include
  • Linker -> General -> Additional Library Directories -> C:\opencv-new \x64\vc14\lib
  • Linker -> Input -> Additional Dependencies -> opencv_core400.lib; opencv_face400.lib; opencv_videoio400.lib; opencv_objdetect400.lib; opencv_imgproc400.lib; opencv_highgui400.lib

При запуске программа выдает ошибку, если в установках проекта Debug. Для Release, запуск успешный.


Выбор признаков для фильтрации изображений и распознавания лиц

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

Объективные факторы — положение лица относительно камеры.

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

При видеозахвате иногда проскакивают и такие изображения. Их нужно отфильтровывать — как при обучении так и распознавании.

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

Для сравнения лиц можно использовать точечный 2D каркас одного и того же положения лица. Какое положение лица относительно камеры есть наиболее информативным? Очевидно, что фронтальное. Не зря в криминалистике делают фото в анфас и профиль. Пока ограничимся анфасом.

Все признаки (расстояния) должны быть безразмерные (нормализованые), т.е., соотнесены к какому-то размеру(расстоянию). Предполагаю, что наиболее подходящий для этого размер — расстояние между серединами угловых точек глаз. А почему, например, не внешними угловыми точками глаз, которые реально определены в массиве landmarks? Дело в том, что угловые точки глаз раздвигаются (сближаются) при реагировании на изменение цвета, выражении удивления, моргании и т.п. Расстояние между серединами глаз нивелирует эти колебания и поэтому более предпочтительно.

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

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

Оставляем только те точечные каркасы, которые проходят по следующим признакам:

  • Прямая, которая проходит через крайние точки глаз (линия глаз), перпендикулярна прямой, которая проходит через крайние точки носа (линия носа).
  • Линия глаз параллельна прямой, которая проходит через точки уголков рта (линия рта).
  • Соблюдается симметрия указанных выше точек относительно линии носа.
  • Угловые точки глаз (внешние и внутренние) находятся на одной прямой.

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

Пример изображений, которые отфильтровываются:

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

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

Алгоритм распознавания лиц по 2D-каркасу точек

Координаты точек каркаса лица изначально задаются в системе координат, которая привязана к верхней левой точке окна. При этом ось Y направлена вниз.

Для удобства определения признаков используем пользовательскую систему координат (ПСК), ось X которой проходит через отрезок между серединами глаз, а ось Y — перпендикулярно этому отрезку через его середину в направлении вверх. Координаты ПСК (от -1 до +1) нормализованы — соотнесены с расстоянием между средними точками глаз.

ПСК обеспечивает удобство и простоту определения признаков. Например, положение лица в анфас определяется признаком симметрии соответствующих точек глаз относительно линии носа. Этот признак формализуется совпадением линии носа с осью Y, т.е X1=X2=0, где X1 и X2 — координаты крайних точек носа (27 и 30) в ПСК.

Определяем относительно оконной СК

Координаты средних точек левого и правого глаз (Left и Right):

XL = (X45 + X42) /2 ; YL = (Y45 + Y42) /2 ; XR = (X39 + X 36) /2; YR = (Y39 + Y 36) /2;

Начало ПСК:

X0 =(XL + XR)/2; Y0 =(YL + YR)/2;

Расстояния между средними точками глаз вдоль осей Х и Y:

DX = XR — XL; DY = YR — YL;

Действительное расстояние L между средними точками глаз (по теореме Пифагора):

L = sqrt (DX** 2 + DY**2)

Тригонометрические функции угла поворота ПСК:

Переходим от координат в оконной СК к координатам в ПСК , используя параметры X0,Y0, L, sin AL, cos AL:

X_User_0 = 2 (X_Window — X0) / L;

Y_User_0 = — 2 (Y_Window — Y0) / L ;

X_User = X_User_0 * cos_AL — Y_User_0 * sin_AL;

Y_User = X_User_0 * sin_AL + Y_User_0 * cos_AL;

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

1.Признак перпендикулярности линий носа и глаз, а также симметрии угловых точек глаз . Линия носа определяется точками 27 и 30 (см. рисунок во ). Оба признака выполняются, если в ПСК координаты этих точек X1 = X2= 0 (т.е., линия носа совпадает с осью Y).

2.Признак параллельности линии глаз и линии рта . Линия рта определяется точками 48 и 54 (см. рисунок во ). Признак выполняется, если в ПСК Y1-Y2=0.

3. Признак симметрии угловых точек рта . Линия рта определяется точками 48 и 54 (см. рисунок во ). Признак выполняется, если в ПСК X1+X2 =0

4. Признак «Угловые точки глаз находятся на одной прямой» . Прямые определяются парами точек: (36 и 45), а также (39 и 42). Поскольку тест по признаку 1 уже пройден, достаточно лишь определить в ПСК признак Y2-Y1 =0 лишь для точек 36 и 39.

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

Программа сравнения лиц по одному признаку

В качестве признака берется расстояние между точками переносицы и подбородка (Landmarks точками 27 и 8, см. рисунок во ). Признак, нормализован, определяется в ПСК отношением: (Y1 — Y2)/L , где L — расстояние между центрами глаз. При обучении программы признак для конкретного лица определяется числом, которое высвечивается рядом с отслеживаемым лицом (эта часть кода в программе закомментирована). При распознавании значение признака сравнивается с введенным в программу конкретным признаком для каждого лица. При положительном результате сравнения рядом с лицом появляется его идентификатор.

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

Контрольные задания:

  1. Ознакомиться с программой.
  2. Определить значение признака для своего лица и нескольких своих коллег.
  3. Протестировать программу на предмет идентификации лиц (своего и коллег).

#include #include #include #include #include #include #include "drawLandmarks.hpp" using namespace std; using namespace cv; using namespace cv::face; int main(int argc, char** argv) { // Load Face Detector CascadeClassifier faceDetector("haarcascade_frontalface_alt2.xml"); // Create an instance of Facemark Ptr facemark = FacemarkLBF::create(); // Load landmark detector facemark->loadModel("lbfmodel.yaml"); // Set up webcam for video capture VideoCapture cam(0); // Variable to store a video frame and its grayscale Mat frame, gray; // Read a frame while (cam.read(frame)) { // Find face vector faces; // Convert frame to grayscale because // faceDetector requires grayscale image. cvtColor(frame, gray, COLOR_BGR2GRAY); // Detect faces faceDetector.detectMultiScale(gray, faces); // Variable for landmarks. // Landmarks for one face is a vector of points // There can be more than one face in the image. Hence, we // use a vector of vector of points. vector< vector > landmarks; // Run landmark detector bool success = facemark->fit(frame, faces, landmarks); if (success) { // If successful, render the landmarks on the face for (size_t i = 0; i < faces.size(); i++) { cv::rectangle(frame, faces[i], Scalar(0, 255, 0), 3); } for (int i = 0; i < landmarks.size(); i++) { //if((i >=30)&&(i <= 35)) drawLandmarks(frame, landmarks[i]); for (size_t j = 0; j < landmarks[i].size(); j++) { circle(frame, Point(landmarks[i][j].x, landmarks[i][j].y), 1, Scalar(255, 0, 0), 2); } line(frame, Point(landmarks[i].x, landmarks[i].y), Point(landmarks[i].x, landmarks[i].y), Scalar(0, 0, 255), 2); float XL = (landmarks[i].x + landmarks[i].x) / 2; float YL = (landmarks[i].y + landmarks[i].y) / 2; float XR = (landmarks[i].x + landmarks[i].x) / 2; float YR = (landmarks[i].y + landmarks[i].y) / 2; line(frame, Point(XL, YL), Point(XR, YR), Scalar(0, 0, 255), 2); float DX = XR - XL; float DY = YR - YL; float L = sqrt(DX * DX + DY * DY); float X1 = (landmarks[i].x); float Y1 = (landmarks[i].y); float X2 = (landmarks[i].x); float Y2 = (landmarks[i].y); float DX1 = abs(X1 - X2); float DY1 = abs(Y1 - Y2); float L1 = sqrt(DX1 * DX1 + DY1 * DY1); float X0 = (XL + XR) / 2; float Y0 = (YL + YR) / 2; float sin_AL = DY / L; float cos_AL = DX / L; float X_User_0 = (landmarks[i].x - X0) / L; float Y_User_0 = -(landmarks[i].y - Y0) / L; float X_User27 = X_User_0 * cos_AL - Y_User_0 * sin_AL; float Y_User27 = X_User_0 * sin_AL + Y_User_0 * cos_AL; X_User_0 = (landmarks[i].x - X0) / L; Y_User_0 = -(landmarks[i].y - Y0) / L; float X_User30 = X_User_0 * cos_AL - Y_User_0 * sin_AL; float Y_User30 = X_User_0 * sin_AL + Y_User_0 * cos_AL; if (abs(X_User27 - X_User30) <= 0.1) { //putText(frame, std::to_string(abs(L1 / L)), Point(landmarks[i].x, landmarks[i].y), 1, 2, Scalar(0, 0, 255), 2); if (abs((L1 / L) - 1.6) < 0.1) { putText(frame, "Roman", Point(landmarks[i].x, landmarks[i].y), 1, 2, Scalar(0, 0, 255), 2); } if (abs((L1 / L) - 1.9) < 0.1) { putText(frame, "Pasha", Point(landmarks[i].x, landmarks[i].y), 1, 2, Scalar(0, 0, 255), 2); } if (abs((L1 / L) - 2.1) < 0.1) { putText(frame, "Svirnesvkiy", Point(landmarks[i].x, landmarks[i].y), 1, 2, Scalar(0, 0, 255), 2); } } putText(frame, "Incorrect", Point(landmarks[i].x, landmarks[i].y), 1, 2, Scalar(0, 0, 255), 2); } } // Display results imshow("Facial Landmark Detection", frame); // Exit loop if ESC is pressed if (waitKey(1) == 27) break; } return 0; }