Код подпрограммы cvHashCalc

#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 <stdlib.h>

#include <opencv\cv.h>

#include <iostream>

#include <fstream>

#include <sstream>

#include <string>

#include <vector>

#include <algorithm>

#include <Windows.h>

using namespace std;

using namespace cv;

__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++;

}

}

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;

}

template< typename T >

inline std::string convertToString(T o)

{

std::ostringstream oss;

oss << o;

return oss.str();

}

vector<string> split(const string& s, const string& delim, const bool keep_empty = true) {

vector<string> result;

if (delim.empty()) {

result.push_back(s);

return result;

}

string::const_iterator substart = s.begin(), subend;

while (true) {

subend = search(substart, s.end(), delim.begin(), delim.end());

string temp(substart, subend);

if (keep_empty || !temp.empty()) {

result.push_back(temp);

}

if (subend == s.end()) {

break;

}

substart = subend + delim.size();

}

return result;

}

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

{

char ownPth[255];

// Will contain exe path

HMODULE hModule = GetModuleHandle(NULL);

if (hModule != NULL)

{

GetModuleFileName(hModule,ownPth, (sizeof(ownPth)));

}

else

{

cout << "Module handle is NULL" << endl ;

system("PAUSE");

return 0;

}

std::string mypath;

mypath = (const char*) ownPth;

vector<string> words = split(mypath, "\\");

words.pop_back();

words.pop_back();

words.pop_back();

words.push_back("\cvFaceHash");

words.push_back("\cvFaceHash");

words.push_back("\database.txt");

string db_path = "";

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

{

db_path += words[i];

db_path += "\\";

}

db_path += words.back();

string name;

int i=0;

Mat gray;

string databasefilename;

databasefilename = db_path;

std::ofstream file;

file.open(databasefilename);

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

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(int 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);

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);

Mat Roi1 = img4;

char c = cvWaitKey(33);

if (c == 27)

{ // нажата ESC

iswork = false;

}

else if(c == 13)

{ // Enter

// сохраняем кадр в файл

sprintf(filename, "face#%d.jpg", counter);

printf("[i] capture... %s\n", filename);

imwrite(filename, Roi1);

counter++;

}

}

}

//print the output

imshow("outputCapture", captureFrame);

//pause for 33ms

waitKey(33);

}

cout << "Calculate Hash for captured faces" << endl;

for (i=0; i<counter; i++)

{

name = "Face#" + to_string(i)+".jpg";

Mat img= imread(name.c_str(),1);

if(!img.data ) break;

IplImage* image2=cvCloneImage(&(IplImage)img);

__int64 hashO = calcImageHash(image2, true);

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

std::string my_string = "";

char hashbuff[32];

_ui64toa(hashO,hashbuff, 16);

std::string hashstr(hashbuff);

my_string = hashstr;

my_string += ":";

my_string += name;

my_string += "\n";

file << my_string;

imshow("src",img);

waitKey();

}

file.close();

return 0;

}

87