Список использованных источников

1. Azhar Hadmi, William Puech, Brahim Ait Es Said, Abdellah Ait Ouahman. Perceptual Image Hashing, watermarking – Volume 2. University of Montpellier II, CNRS UMR 5506-LIRMM. INTECH. 2012. – C. 27.

2. Viola P., Jones M.J.Rapid object detection using a boosted cascade of simple features // IEEE Conf. on Computer Vision and Pattern Recognition. – Kauai, Hawaii, USA, 2001. – V. 1. – P. 511–518.

3. Viola P., Jones M.J.Robust real time face detection // International Journal of Computer Vision. – 2004. – V. 57. – № 2. – C. 137–154.

4. Гонсалес P., Вудс Р. Цифровая обработка изображений. – М.:Техносфера, 2005. – 1072 с.

5. Jan ˇSochman, Jiˇr´ı Matas, «AdaBoost», Center for Machine Perception, Czech Technical University, Prague, 2010.

6. Yoav Freund, Robert E. Schapire, «A Short Introduction to Boosting», Shannon Laboratory, USA, 1999., C. 771-780.

7. Bradsky G., Kaehler A. Learning OpenCV — O’Reilly, 2008. — C. 1.

8. Компаниец В.С. Учебно-методическое пособие по выполнению раздела «Безопасность и экологичность» в дипломных проектах (работах) студентов специализации в области информатики и ВТ. Таганрог: Изд-во ТТИ ЮФУ, 2008. 3 п.л.

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

#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 <opencv\cv.h>

#include <iostream>

#include <fstream>

#include <string>

#include <vector>

#include <stdlib.h>

#define EQIV_COEF 30

using namespace cv;

using namespace std;

int hamm_distance = 1;

int const max_hamm_dist = 50;

char* trackbar_type = "Hamming distance";

char* window_name = "Filtered frame";

#define EQIV_COEF 30

Mat captureFrame;

bool hash_eqviv(int distance)

{

if (distance < hamm_distance)

{

return true;

}

else

{

return false;

}

}

__int64 calcImageHash(IplImage* src, bool show_results)

{

if(!src){

return 0;

}

IplImage *res=0, *gray=0, *bin =0;

res = cvCreateImage( cvSize(16, 16), src->depth, src->nChannels);

gray = cvCreateImage( cvSize(16, 16), IPL_DEPTH_8U, 1);

bin = cvCreateImage( cvSize(16, 16), IPL_DEPTH_8U, 1);

// уменьшаем картинку

cvResize(src, res);

// переводим в градации серого

cvCvtColor(res, gray, CV_BGR2GRAY);

// вычисляем среднее

CvScalar average = cvAvg(gray);

printf("[i] average: %.2f \n", average.val[0]);

// получим бинарное изображение относительно среднего

cvThreshold(gray, bin, average.val[0], 255, CV_THRESH_BINARY);

// построим хэш

__int64 hash = 0;

int i=0;

// пробегаемся по всем пикселям изображения

for( int y=0; y<bin->height; y++ ) {

uchar* ptr = (uchar*) (bin->imageData + y * bin->widthStep);

for( int x=0; x<bin->width; x++ ) {

// 1 канал

if(ptr[x]){

hash |= 1i64<<i;

}

i++;

}

}

printf("[i] hash: %I64X \n", hash);

if(show_results){

// увеличенные картинки для отображения результатов

IplImage* dst3 = cvCreateImage( cvSize(128, 128), IPL_DEPTH_8U, 3);

IplImage* dst1 = cvCreateImage( cvSize(128, 128), IPL_DEPTH_8U, 1);

// показываем картинки

cvNamedWindow( "64");

cvResize(res, dst3, CV_INTER_NN);

cvShowImage( "64", dst3 );

cvNamedWindow( "gray");

cvResize(gray, dst1, CV_INTER_NN);

cvShowImage( "gray", dst1 );

cvNamedWindow( "bin");

cvResize(bin, dst1, CV_INTER_NN);

cvShowImage( "bin", dst1 );

cvReleaseImage(&dst3);

cvReleaseImage(&dst1);

}

// освобождаем ресурсы

cvReleaseImage(&res);

cvReleaseImage(&gray);

cvReleaseImage(&bin);

return hash;

}

// рассчитать хеш картинки

__int64 calcImageHash(IplImage* image, bool show_results=false);

// рассчёт расстояния Хэмминга

__int64 calcHammingDistance(__int64 x, __int64 y)

{

__int64 dist = 0, val = x ^ y;

// Count the number of set bits

while(val)

{

++dist;

val &= val - 1;

}

return dist;

}

class cBaseElement

{

public:

__int64 hash;

string filename;

public:

cBaseElement(){};

~cBaseElement(){};

};

class cFaceBase

{

public:

vector<cBaseElement> database;

public:

cFaceBase(){};

~cFaceBase(){};

void loadBase(string filename);

vector <string> split(const string& str, string& delimiter);

};

vector <string> cFaceBase::split(const string& str, string& delimiter)

{

vector <string> tokens;

string::size_type lastPos = 0;

string::size_type pos = str.find(delimiter, lastPos);

while (string::npos != pos) {

tokens.push_back(str.substr(lastPos, pos - lastPos));

lastPos = pos + delimiter.size();

pos = str.find(delimiter, lastPos);

}

tokens.push_back(str.substr(lastPos, str.size() - lastPos));

return tokens;

}

void cFaceBase::loadBase(string filename)

{

// загружаем содержимое файла в вектор строк

std::vector<std::string> words;

std::ifstream file(filename);

std::string word;

while (file >> word)

{

words.push_back(word);

}

cout << "Database is: " << endl;

for (unsigned int i = 0; i < words.size(); i++)

{

cout << words[i] << endl;

}

for (unsigned int i = 0; i < words.size(); i++)

{

string delimeter = ":";

vector <string> asd = split(words[i], delimeter);

cBaseElement elem;

elem.filename = asd[1];

__int64 bigint;

sscanf(asd[0].c_str(), "%I64X", &bigint);

elem.hash = bigint;

database.push_back(elem);

}

}

/**

* @функция Threshold_Demo

*/

void Threshold_Demo( int, void* )

{

}

__int64 hashwithminhammdis(__int64 hash)

{

cFaceBase faceBase;

faceBase.loadBase("database.txt");

int m1 = 50;

unsigned int k = 0;

int m2 = 0;

string ham[30];

for (size_t j = 0; j < faceBase.database.size(); j++)

{

m2 = calcHammingDistance(hash, faceBase.database[j].hash);

ham[j] = to_string((_ULonglong)m2);

m2 = atoi (ham[j].c_str());

if (m2 < m1)

{

m1 = m2;

k = j;

}

}

cout << "min element is #" << k <<endl;

return k;

}

int main(int argc, const char** argv)

{

cFaceBase faceBase;

faceBase.loadBase("database.txt");

//создаем объект каскада классификаторов для распознавания лиц,

CascadeClassifier face_cascade;

//используем haarcascade_frontalface_alt.xml библиотеку

face_cascade.load("haarcascade_frontalface_alt.xml");

//устанавливаем соединение с первым устройством захвата видео

VideoCapture captureDevice;

captureDevice.open(0);

//Файлы изображений, используемые в процессе захвата

Mat grayscaleFrame;

//создаем окно для представления результатов

string wnd_output_capture_base = "outputCapture";

string wnd_output_capture_coord = "";

namedWindow(wnd_output_capture_base.c_str(), 1);

//создать цикл, чтобы захватить и найти лица

while(true)

{

//захватываем новый кадр изображения

captureDevice>>captureFrame;

// создаем Trackbar и выбираем размер порога

createTrackbar(trackbar_type, wnd_output_capture_base, hamm_distance,max_hamm_dist, Threshold_Demo );

cvtColor(captureFrame, grayscaleFrame, CV_BGR2GRAY);

equalizeHist(grayscaleFrame, grayscaleFrame);

// создаем векторный массив для хранения лица

std::vector<Rect> faces;

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

face_cascade.detectMultiScale(grayscaleFrame, faces, 1.1, 3, CV_HAAR_FIND_BIGGEST_OBJECT|CV_HAAR_SCALE_IMAGE, Size(100,100));

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

for(size_t i = 0; i < faces.size(); i++)

{

Point pt1(faces[i].x + faces[i].width, 

faces[i].y + faces[i].height);

Point pt2(faces[i].x, faces[i].y);

rectangle(captureFrame, pt1, pt2,

cvScalar(0, 255, 0, 0), 1, 8, 0);

string wnd_face_name = "rect";

cvNamedWindow(wnd_face_name.c_str(), CV_WINDOW_AUTOSIZE);

if (faces.size() == 1)

{

int x = faces[i].x;

int y = faces[i].y;

int h = faces[i].height;

int w = faces[i].width;

IplImage* img3=cvCloneImage(&(IplImage)captureFrame);

cvSetImageROI(img3, cvRect(x, y, w, h));

IplImage *img4 = cvCreateImage(cvGetSize(img3),

img3->depth,

img3->nChannels);

cvCopy(img3, img4, NULL);

cvResetImageROI(img3);

cvNamedWindow(wnd_face_name.c_str(),CV_WINDOW_AUTOSIZE);

cvShowImage(wnd_face_name.c_str(), img4);

Mat Roi1 = img4;

imwrite("cat1.jpg", Roi1);

}

IplImage *object=0;

char obj_name[] = "cat1.jpg";

// имя объекта задаётся первым параметром

char* object_filename = obj_name;

// получаем картинку

object = cvLoadImage(object_filename, 1);

// покажем изображение

cvNamedWindow( "object");

cvShowImage( "object", object );

// построим хэш

__int64 hashO = calcImageHash(object, true);

unsigned int k = hashwithminhammdis(hashO);

for (size_t j = 0; j < faceBase.database.size(); j++)

{

If (hash_eqviv(calcHammingDistance(hashO, faceBase.database[k].hash)))

{

cout << "detected." << endl;

for(size_t i = 0; i < faces.size(); i++)

{

Point pt1(faces[i].x + faces[i].width - 10, faces[i].y + faces[i].height-10);

Point pt2(faces[i].x + 10, faces[i].y + 10);

rectangle(captureFrame, pt1, pt2,

cvScalar(0, 255, 255, 0), 1, 8, 0);

string text = faceBase.database[k].filename;

int fontFace = 3;

double fontScale = 1;

int thickness = 3;

cv::Point textOrg(faces[i].x, faces[i].y);

cv::putText(captureFrame, text, textOrg,

fontFace, fontScale, Scalar::all(255),

thickness,3);

}

}

}

cout << endl;

}

imshow(wnd_output_capture_base, captureFrame);

//пауза в 33мс

waitKey(33);

}

return 0;

}