Таким образом, на входе будут следующие исходные данные:

1) - центр изображения, где , - разрешение изображения.

2) -положение центра лица в текущий момент времени

3) - положение центра лица в предыдущий момент времени.

Теперь необходимо сформулировать правила, по которым будет приниматься решение куда смещать камеру.

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

Рассмотрим возможные положения объекта относительно центра:

1)

2)

3)

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

Рассмотрим значение d: в данном случае это регулируемая величина, по сути это «коридор», находясь в котором центр объекта считается расположенной в центре экрана.

В общем, алгоритм принятия решений можно представить в виде модели дерева (рис.18).

Есть три 4 варианта действий:

14) 0 - остановка камеры;

15) 1 - смещение камеры вправо;

16) 2- смещение камеры влево

17) 4 - никаких действий не предпринимается.

Данный алгоритм легко реализуется на C++.

Рис. 21 Алгоритм принятия решений

6. Исследование системы

6.1 Оценка точности перенацеливания

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

Отклонение
1.06415
3.70325
4.80161
4.72842
3.26971
8.73123
5.85681
2.43057
1.98102
1.77615
1.58008
3.75018
Среднее отклонение = 3,6394 пикс.



6.2 Проверка на устойчивость к смене освещения

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

6.3 Время задержки

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

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

Данная величина вполне соответствует условиям выполнения в режиме реального времени.

6.4 Устойчивость при частичном перекрытии объекта

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



6.5 Анализ влияния шумов

Рассмотрим видеоизображение, полученное с веб-камеры с разрешением 640x480. Будем вычислять значение заранее заданной неподвижной точки в каждый момент времени и сравнивать ее значение в предыдущий момент. Как наглядно показывают результаты эксперимента на таблице 4, эта разница никогда не равна нулю. К таким зашумленным изображениям целесообразно применять функцию сглаживания для уменьшения влияния шумов и тем самым увеличения точности прогноза.

Таблица 4. Результаты наблюдений

1.02921	0.115829
1.48715	0.295242
1.3222	1.09048
0.992188	0.382339
1.0459	0.894623
1.3714	1.3714
0.786346	1.1476
1.45007	1.28172
1.03217	1.22472
0.734528	0.68219
0.671539	0.737686
1.22433	0.452148
1.21979	0.807755
0.661194	1.25108
= 1.0734 пикс.	=0,8382 пикс.

Из данных результатов можно сделать вывод, что детектирования мелких объектов, а тем более их смещение в таком изображении не будет осуществляться с требуемой точностью

Заключение

В данной работе был разработан программно-аппаратный комплекс, который осуществляет анализ видеоизображения, путем поиска лица человека с помощью алгоритма Виолы-Джонса в режиме реального времени, а затем осуществляет слежение методом пирамидального оптического потока Лукаса-Канаде. В процессе слежения осуществляется движение видеокамеры в сторону движения объекта. Программа была написана на языке C/C++ в среде разработки QT Creator с использованием библиотеки компьютерного зрения OpenCV.

Преимущества разработанной системы:

1) Работа в режиме реального времени

2) Возможность обучить модель на поиск определенного объекта или определенного человека.

3) Устойчивость поиска при смене освещенности

4) Устойчивость слежения при частичном перекрытии объекта (не более чем 50% )

5) Возможность работы с изображением низкого качества

Недостатки:

1) Работа в двумерном пространстве без учета пространственной ориентации объекта.

2) Существенное время задержки получения изображения.

3) Неустойчивость алгоритма слежения к аффинным преобразованиям.

Рекомендации по улучшению работы программно-аппаратного комплекса:

1) Переход от двумерной системы координат к пространственной системе координат.

2) Работа одновременно с двумя и более камерами для создания 3D-модели объекта и распознавание при любой ориентации объекта в пространстве.

3) Улучшение работы алгоритма слежения за объектом путем учета аффинных преобразований

4) Для повышения быстродействия и сокращения времени отклика программы рекомендуется распараллеливание вычислений алгоритмов.



Список литературы

1. Fisher R. CVOnline: Motion and time sequence Analysis [Электронный ресурс]. - 2002

2. Morris R. An Integrated Traffic and Pedestrian Vision System [Электронный ресурс]. - 1998

3. Вежневец В. Введение в Computer Vision [Электронный ресурс]. - 2003

4. Davies D., Palmer P., Mirmehdi M. Detection and Tracking of Very Small Low Contrast Objects [Электронный ресурс]. - 1994

5. Сойфер В.А. Компьютерная обработка изображений. Часть 2. Методы и алгоритмы. Соросовский образовательный журнал, №3, 1996, с. 110 - 121.

6. Р.Гонсалес, Р.Вудс, «Цифровая обработка изображений», ISBN 5-94836-028-8, изд-во: Техносфера, Москва, 2005. - 1072 с.

7. Козлов В. Н., Функциональный анализ, Санкт-Петербург: СПбГПУ, 2012, c. 461.

8. Тули М. Справочное пособие по цифровой электронике: Пер. с англ. -- М.: Энергоатомиздат, 1990.

9. Sony BRC H900 Command List

10. Sony BRC H900 Operating Manual

11.Bechtel W. The Cardinal Mercier Lectures at the Catholic University of Louvain: An Exemplar Neural Mechanism: The Brain's Visual Processing System. 2003

12. Программно-аппаратный комплекс AxxonNext [Электронный ресурс]. - Режим доступа: http: //www. axxonnext. com.

13. Программно-аппаратный комплекс подсчета пассажиров DL-Bus [Электронный ресурс

14. G. Yang and Thomas S. Huang. «Human face detection in a complex background. Pattern Recognition», 27(1):53-63, 1994

15. C. Kotropoulos, I. Pitas. «Acoustics, Speech, and Signal Processing», 1997. ICASSP-97, 1997 IEEE International Conference on p.2537-2540 v. 4

16. T. K. Leung, M. C. Burl, P. Perona. «Finding Faces in Cluttered Scenes Using Random Labeled Graph Matching»

17. K. C. Yow, R Cipolla, «Feature-based human face detection», Image and vision computing 15 (9),p. 713-735, 1997

18. Татаренков Д. А. Анализ методов обнаружения лиц на изображении // Молодой ученый. -- 2015. -- №4. -- С. 270-276.

19. Lanitis, A.; Taylor, C.J.; Ahmed, T.; Cootes, T.F.; Wolfson «Image Anal. Classifying variable objects using a flexible shape model» Image Processing and its Applications, 1995., p.70-74

20. Горбунов В.М. Теория принятия решений. Учебное пособие, Томск, 2010, с.67

21. Прейко М., Устройства управления роботами: схемотехника и программирование - М.: Издательство ДМК, 2004, 202с.



Приложение 1. Код программы

Файл Mainwindow.h

#ifndef MAINWINDOW_H

#define MAINWINDOW_H

#include <opencv2/core/core.hpp>

#include <opencv2/features2d/features2d.hpp>

#include <opencv2/highgui/highgui.hpp>

#include <opencv2/imgproc/imgproc.hpp>

#include <opencv2/nonfree/nonfree.hpp>

#include <opencv2/objdetect/objdetect.hpp>

#include <QtSerialPort/QSerialPort>

#include <QtSerialPort/QSerialPortInfo>

#include "cv.h"

#include "highgui.h"

#include <stdio.h>

#include <ctype.h>

#include <QMainWindow>

#include <opencv\cv.h>

#include <iostream>

#include <stdlib.h>

#include <QDebug>

#include <algorithm>

#include <limits>

#include <time.h>

#include <math.h>

#include "myport.h"

#include <QThread>

#include "tracking.h"

#undef min

#undef max

namespace Ui {

class MainWindow;

}

class MainWindow : public QMainWindow

{

Q_OBJECT

public:

explicit MainWindow(QWidget *parent = 0);

~MainWindow();

IplImage* first_img;

// int add_pt;

MyPort *port422;

// CvPoint2D32f *window_center;

IplImage *image;//для детектирования лица

CvRect target;//интересующая область

CvPoint pt;

CvPoint2D32f window_center;

CvPoint2D32f prev_mass_center;

CvPoint2D32f mass_center;

bool object_moving;

float sum;

// CvPoint2D32f mass_center_next;

// CvRect face_size;

bool detect_face(IplImage *gray, CvHaarClassifierCascade *haar_cascade, CvMemStorage *mem_storage, CvRect &face_rect);

QSerialPort *serial;

QByteArray command_read;

QByteArray command;

// unsigned char camera_id;

void init(const IplImage *gray, const CvRect &face_rect);

void deinit();

bool object_tracking (IplImage *gray, CvRect &face_rect);

signals:

void send_command (QByteArray command );

private slots:

void on_pushButton_up_clicked();

void on_pushButton_down_clicked();

void on_pushButton_left_clicked();

void on_pushButton_right_clicked();

void on_pushButton_clicked();

private:

Ui::MainWindow *ui;

IplImage *prev_img;

IplImage *current_img;

IplImage *previous_pyramid;

IplImage *current_pyramid;

int count_point;

CvPoint2D32f *current_points;

CvPoint2D32f *prev_points;

char *status;

CvTermCriteria tc;

int flags;

};

#endif // MAINWINDOW_H

Файл myport.h

#ifndef MYPORT_H

#define MYPORT_H

#include <QObject>

#include <QDebug>

#include <QtSerialPort/QserialPort>//Обьявляем работу с портом

#include <QMainWindow>

#include "math.h"

#include <unistd.h>

struct Settings {//Структура с настройками порта

QString name;

// // qint32 baudRate;

// QSerialPort::DataBits dataBits;

// QSerialPort::Parity parity;

// QSerialPort::StopBits stopBits;

// QSerialPort::FlowControl flowControl;

// QSerialPort::setSettingsRestoredOnClose setSettingsRestoredOnClose;

};

class MyPort : public QObject

{

Q_OBJECT

public:

explicit MyPort(QObject *parent = 0);

~MyPort();//хз

QSerialPort thisPort;

Settings SettingsPort;

//QByteArray command;

QByteArray command_read;

unsigned char camera_id = 0x83;

float s;

signals:

void finished_Port(); //Сигнал закрытия класса

void error_(QString err);//Сигнал ошибок порта

void outPort(QString data); //Сигнал вывода полученных данных

public slots:

void ClosePort(); // Слот отключения порта

void ConnectPort(void); // Слот подключения порта

void StopMoving();

void left();

void right ();

// void Write_Settings_Port();// Слот занесение настроек порта в класс

void process_Port(); //Тело

void choose_action (float prev, float next, float window_center);

void WriteToPort(QByteArray data); // Слот от правки данных в порт

private slots:

void handleError(QSerialPort::SerialPortError error);//Слот обработки ощибок

void ReadInPort(); //Слот чтения из порта по ReadyRead

};

#endif // MYPORT_H

Файл Main.cpp

#include "mainwindow.h"

#include <QApplication>

#include <QCoreApplication>

#include <opencv2/imgproc/imgproc.hpp>

#include <opencv2/highgui/highgui.hpp>

int main(int argc, char *argv[])

{

QApplication a(argc, argv);

MainWindow w;

w.show();

return a.exec();

}

Файл Mainwindow.cpp

#include "mainwindow.h"

#include "ui_mainwindow.h"

#include <QFileDialog>

#include <QDebug>

#include <QtDebug>

#include <QString>

#include <windows.h>

#include <iostream>

using namespace std;

using namespace cv;

MainWindow::MainWindow(QWidget *parent) :

QMainWindow(parent),

ui(new Ui::MainWindow)

{

ui->setupUi(this);

/*для порта и передачи команд*/

//camera_id = 0x83;

//serial = new QSerialPort(this);

//serial->setPortName("COM1");

current_img = NULL;

prev_img = NULL;

current_pyramid = NULL;

previous_pyramid = NULL;

count_point = 0;

flags = 0;

current_points = NULL;

prev_points = NULL;

status = NULL;

object_moving=false;

sum =0;

QThread *my_thread = new QThread;//Создаем поток для порта платы

MyPort *port422 = new MyPort();//Создаем обьект по классу

port422->moveToThread(my_thread);//помешаем класс в поток

port422->thisPort.moveToThread(my_thread);//Помещаем сам порт в поток

// port422->

//Загружаем обученные данные для классификатора

CvHaarClassifierCascade *cascade_frontal_face = (CvHaarClassifierCascade *)cvLoad("D:/openCV/opencv/sources/data/haarcascades/haarcascade_frontalface_alt.xml", 0, 0, 0);

//"D:/openCV/opencv/sources/data/haarcascades/haarcascade_mcs_upperbody.xml"

if (!cascade_frontal_face)

{

qDebug()<<"Error to load model"<<endl;

close();

}

CvMemStorage *MemStorage = cvCreateMemStorage(0);

tc = cvTermCriteria(CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03);

// connect(port422, SIGNAL(error_(QString)), this, SLOT(Print(QString)));//Лог ошибок

connect(my_thread, SIGNAL(started()),port422, SLOT(process_Port()));//Переназначения метода run

connect(port422, SIGNAL(finished_Port()), my_thread, SLOT(quit()));//Переназначение метода выход

connect(my_thread, SIGNAL(finished()),port422, SLOT(deleteLater()));//Удалить к чертям поток

connect(port422, SIGNAL(finished_Port()),my_thread, SLOT(deleteLater()));//Удалить к чертям поток

connect(this,SIGNAL(send_command(QByteArray)),port422,SLOT(WriteToPort(QByteArray)));//отправка в порт данных

//Захватываем видео (можно и с камеры) с лицами

port422->ConnectPort();

CvCapture* capture_web = cvCaptureFromCAM (0);

assert( capture_web );

if (capture_web == NULL)

{

qDebug()<<"Error to catch the camera!!!!"<<endl;

cvClearMemStorage(MemStorage);

cvRelease((void **)&cascade_frontal_face);

close();

}

cvNamedWindow("frame", 1);

// cvNamedWindow("points", 1);

IplImage *gray = NULL;

window_center = cvPoint2D32f(0.f, 0.f);

prev_mass_center = cvPoint2D32f(0.f, 0.f);

mass_center = cvPoint2D32f(0.f, 0.f);

// mass_center_next = cvPoint2D32f(0.f, 0.f);

//Прямоугольник найденного лица

CvRect face_rect = cvRect(0, 0, 0, 0);

//Control control_action;

enum detector_states //Состояния нашего детектора

{

find_object,

track_object

};

detector_states state = find_object;

IplImage *frame = cvQueryFrame(capture_web);

my_thread->start();

while(true)

{

frame = cvQueryFrame(capture_web);

if (frame == NULL)

{

qDebug()<<"Error"<<endl;

break;

}

//Вся работа ведётся на изображении в градациях серого

if (!gray)

{

gray= cvCreateImage(cvSize(frame->width, frame->height), IPL_DEPTH_8U, 1);

//CvPoint2D32f window_center = cvPoint2D32f(0.f, 0.f);

window_center.x = float(frame->width/2);

window_center.y = float(frame->height/2);

// qDebug()<<"Center x:"<<prev_mass_center.x<<endl;

// qDebug()<<"Center y:"<<prev_mass_center.y<<endl;

}

cvCvtColor(frame, gray, CV_RGB2GRAY);

//Наш примитивный автомат

switch (state)

{

case find_object: //Поиск лица

while (detect_face(gray, cascade_frontal_face, MemStorage, face_rect)==false)

{

// cvShowImage("frame", frame);

// cvShowImage("points", gray);

if (cvWaitKey(33) > 0)

break;

frame = cvQueryFrame(capture_web);

// gray= cvCreateImage(cvSize(frame->width, frame->height), IPL_DEPTH_8U, 1);

cvCvtColor(frame, gray, CV_RGB2GRAY);

}

init(gray, face_rect);

state = track_object;

break;

case track_object: //Сопровождение лица

if (!object_tracking(gray, face_rect))

{

unsigned char stop []= {0x83, 0x01, 0x06, 0x01, 0x00, 0x00, 0x03, 0x03, 0xFF};//8x 01 06 01 VV WW 03 03 FF

command.clear();

command.append((char*)stop, sizeof(stop));

send_command(command);

object_moving=false; //Лицо потеряно, деинициализируем данные сопровождения и меняем состояние

qDebug()<<"lost"<<endl;

prev_mass_center.x = NULL;

prev_mass_center.y = NULL;

deinit();

state = find_object;

}

else

{

if (prev_mass_center.x!=NULL)

{

float delta_x = mass_center.x - prev_mass_center.x;

float next = mass_center.x;

// qDebug()<<"next-prev"<<delta_x<<endl;

if (object_moving==false)//если камера неподвижна

{

sum = delta_x + sum;

if ((sum)>10)//объект движется влево

{

//if (window_center-next>0)//движется от края к центра

//break;//ничего не делаем

if ((window_center.x-next)<-30)//движется от центра к краю

{

unsigned char move_right[]= {0x83, 0x01, 0x06, 0x01, 0x03, 0x00, 0x02, 0x03, 0xFF};

command.clear();

command.append((char*)move_right, sizeof(move_right));

send_command(command);

//right();//камеру смещаем вправо

object_moving==true;

sum=0;

//qDebug()<<"next-prev"<<delta_x<<endl;

}

// qDebug()<<"next-prev"<<next-prev<<endl;

}

else if ((sum)<-10)//объект движется вправо

{

if ((window_center.x-next)>0)

{

unsigned char move_left []= {0x83, 0x01, 0x06, 0x01, 0x03, 0x00, 0x01, 0x03, 0xFF};

// 8x 01 06 01 VV WW 01 03 FF

// QByteArray command;

command.clear();

command.append((char*)move_left, sizeof(move_left));

send_command(command);

// left();//камеру смещаем влево

object_moving==true;

sum=0;

}

}

}

else if (fabs(window_center.x-next)<50)//если камера подвижна

{

unsigned char stop []= {0x83, 0x01, 0x06, 0x01, 0x00, 0x00, 0x03, 0x03, 0xFF};//8x 01 06 01 VV WW 03 03 FF

command.clear();

command.append((char*)stop, sizeof(stop));

send_command(command);

object_moving==false;

qDebug()<<"rastoyanie do centra"<<window_center.x-next<<endl;

}

}//moving (prev_mass_center.x, mass_center.x, window_center.x);

}

// }

break;

}

cvDrawRect(frame, cvPoint(face_rect.x, face_rect.y), cvPoint(face_rect.x + face_rect.width, face_rect.y + face_rect.height), cvScalar(255, 0, 0));

cvShowImage("frame", frame);

if (cvWaitKey(8) > 0)

break;

}

cvReleaseCapture(&capture_web);

cvDestroyWindow("frame");

cvDestroyWindow("points");

cvClearMemStorage(MemStorage);

cvRelease((void **)&cascade_frontal_face);

port422->ClosePort();

port422->finished_Port();

//serial->close();

// my_thread->exit();

}

MainWindow::~MainWindow()

{

delete ui;

}

bool MainWindow::detect_face(IplImage *gray, CvHaarClassifierCascade *cascade, CvMemStorage *MemStorage, CvRect &face_rect)

{

cvClearMemStorage(MemStorage);

CvSeq *faces = cvHaarDetectObjects(gray, cascade, MemStorage, 1.1, 3, CV_HAAR_FIND_BIGGEST_OBJECT|CV_HAAR_SCALE_IMAGE

, cvSize(50, 50));

// //Поиск лиц

if (!faces || !faces->total)

return false;

//Возвращаем первое найденное

face_rect = *(CvRect *)cvGetSeqElem(faces, 0);

return true;

// }

}

Файл myport.cpp

#include "myport.h"

MyPort::MyPort(QObject *parent) :

QObject(parent)

{

}

MyPort::~MyPort()

{

qDebug()<<"finish!!"<<endl;

emit finished_Port();//Сигнал о завершении работы

}

void MyPort :: process_Port(){//Выполняется при старте класса

qDebug()<<"Hello!"<<endl;

connect(&thisPort,SIGNAL(error(QSerialPort::SerialPortError)), this, SLOT(handleError(QSerialPort::SerialPortError))); // подключаем проверку ошибок порта

connect(&thisPort, SIGNAL(readyRead()),this,SLOT(ReadInPort()));//подключаем чтение с порта по сигналу readyRead()

}

void MyPort :: ConnectPort(void){//процедура подключения

thisPort.setPortName("COM6");

qDebug()<<"connecting.........."<<endl;

thisPort.setSettingsRestoredOnClose(false);

thisPort.open(QIODevice::ReadWrite);

thisPort.setBaudRate(QSerialPort::Baud9600);

thisPort.setDataBits(QSerialPort::Data8);//DataBits

thisPort.setParity(QSerialPort::NoParity);

thisPort.setStopBits(QSerialPort::OneStop);

thisPort.setFlowControl(QSerialPort::NoFlowControl);

//{

if (thisPort.isOpen()){

qDebug()<<"open"<<endl;

} else {

thisPort.close();

qDebug()<<"error to open port"<<endl;;

}

// object_moving=false;

// s =0;

// } else {

// thisPort.close();

// error_(thisPort.errorString().toLocal8Bit());

// }

}

void MyPort::handleError(QSerialPort::SerialPortError error)//проверка ошибок при работе

{

// if ( (thisPort.isOpen()) && (error == QSerialPort::ResourceError)) {

// error_(thisPort.errorString().toLocal8Bit());

// DisconnectPort();

// }

}//

void MyPort::ClosePort(){//Отключаем порт

unsigned char stop []= {camera_id, 0x01, 0x06, 0x01, 0x00, 0x00, 0x03, 0x03, 0xFF};//8x 01 06 01 VV WW 03 03 FF

QByteArray command;//command.clear();

command.append((char*)stop, sizeof(stop));

WriteToPort(command);

thisPort.waitForBytesWritten(200);

thisPort.close();

qDebug()<<"port closed!!!"<<endl;;

// if(thisPort.isOpen()){

// thisPort.close();

// error_(SettingsPort.name.toLocal8Bit() + " >> Закрыт!\r");

// }

}

void MyPort::StopMoving()

{

unsigned char stop []= {camera_id, 0x01, 0x06, 0x01, 0x00, 0x00, 0x03, 0x03, 0xFF};//8x 01 06 01 VV WW 03 03 FF

QByteArray command;//command.clear();

command.append((char*)stop, sizeof(stop));

WriteToPort(command);

}

void MyPort::ReadInPort()

{

command_read.append(thisPort.readAll());

QByteArray y = command_read.toHex();

command_read.clear();

qDebug()<<"answer"<<y<<endl;

}

void MyPort::left()

{

unsigned char move_left []= {camera_id, 0x01, 0x06, 0x01, 0x03, 0x00, 0x01, 0x03, 0xFF};

// 8x 01 06 01 VV WW 01 03 FF

QByteArray command;

command.append((char*)move_left, sizeof(move_left));

WriteToPort(command);

}

void MyPort:: right()

{

unsigned char move_right[]= {camera_id, 0x01, 0x06, 0x01, 0x03, 0x00, 0x02, 0x03, 0xFF};

//command.clear();

QByteArray command;

command.append((char*)move_right, sizeof(move_right));

WriteToPort(command);

}

void MyPort :: WriteToPort(QByteArray data){//Запись данных в порт

// if(thisPort.isOpen()){

// sleep(7) ;

thisPort.write(data);

qDebug()<<"command is written"<<endl;

thisPort.waitForBytesWritten( 200);

//}

}

Файл tracking.cpp

#include "mainwindow.h"

//слежение за лицом

bool MainWindow::object_tracking (IplImage *gray, CvRect &face_rect)

{

cvCopyImage(gray, current_img);

//Вычисление нового положения точек с помощью пирамидального алгоритма анализа оптического потока Лукаса-Канаде

cvCalcOpticalFlowPyrLK(prev_img, current_img, previous_pyramid, current_pyramid,

prev_points, current_points, count_point, cvSize(20, 20), 3, status, 0, tc, flags);

flags |= CV_LKFLOW_PYR_A_READY;

if (count_point<30)

return false;

//Удаление не найденных точек, а также вычисление координат описывающего прямоугольника

float left = std::numeric_limits<float>::max();

float top = std::numeric_limits<float>::max();

float right = std::numeric_limits<float>::min();

float bottom = std::numeric_limits<float>::min();

//Центр масс

// CvPoint2D32f mass_center = cvPoint2D32f(0.f, 0.f);

// CvPoint2D32f prev_mass_center = cvPoint2D32f(0.f, 0.f);

prev_mass_center = mass_center;

int k = 0;

for (int i = 0; i < count_point; ++i)

{

if (status[i])

{

current_points[k] = current_points[i];

if (current_points[k].x < left)

left = current_points[k].x;

if (current_points[k].x > right)

right = current_points[k].x;

if (current_points[k].y < top)

top = current_points[k].y;

if (current_points[k].y > bottom)

bottom = current_points[k].y;

mass_center.x += current_points[k].x;

mass_center.y += current_points[k].y;

++k;

}

}

count_point = k;

// MainWindow wind;

mass_center.x /= (float)count_point;

mass_center.y /= (float)count_point;

//mass_center_next = mass_center;

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

float min_x = std::min(mass_center.x - left, right - mass_center.x);

float min_y = std::min(mass_center.y - top, bottom - mass_center.y);

//Границы описывающего прямоугольника пересчитываются с учётом полученных минимальных значений + небольшой отступ на всякий случай

left = mass_center.x - min_x - min_x / 4.f;

right = mass_center.x + min_x + min_x / 4.f;

top = mass_center.y - min_y - min_y / 4.f;

bottom = mass_center.y + min_y + min_y / 4.f;

//Удаление точек, которые не попали в новый прямоугольник

k = 0;

for (int i = 0; i < count_point; ++i)

{

if (current_points[i].x > left &&

current_points[i].x < right &&

current_points[i].y > top &&

current_points[i].y < bottom)

{

current_points[k] = current_points[i];

//Вывод точек

cvDrawCircle(gray, cvPoint((int)current_points[k].x, (int)current_points[k].y), 1, cvScalar(255, 0, 255));

++k;

}

}

count_point = k;

// printf("points_count = %i\n", count_point);//записываем сколько точек нашлось

face_rect.x = (int)left;

face_rect.y = (int)top;

face_rect.width = (int)(right - left);

face_rect.height = (int)(bottom - top);

//Смена указателей на параметры

std::swap(prev_img, current_img);

std::swap(previous_pyramid, current_pyramid);

std::swap(prev_points, current_points);

cvShowImage("points", gray);

return true;

}

Размещено на Allbest.ru

...