OpenCV обнаружение лиц с камеры

#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 <stdio.h>
#include <stdlib.h>
 
 
using namespace std;
using namespace cv;
 
int main(int argc, const char** argv)
{
 
 
    CascadeClassifier face_cascade;
    face_cascade.load("haarcascade_frontalface_alt.xml");
 
    
    VideoCapture captureDevice;
    captureDevice.open(0);
 
    
    Mat captureFrame;
    Mat grayscaleFrame;
 
    
    namedWindow("outputCapture", 1);
    
 
    while(true)
    {
        captureDevice>>captureFrame;
 
        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(50,50));
 
 
        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);
                    
 
            
        }
        
        imshow("outputCapture", captureFrame);
    
        waitKey(33);
    }
 
    return 0;
}

#include <opencv2\opencv.hpp>
#include <opencv2\core\core.hpp>
#include <opencv2\imgproc\imgproc.hpp>
#include <opencv2\highgui\highgui.hpp>
 
#include <string>
#include <iostream>
 
#define EQIV_COEF 30
 
using namespace std;
using namespace cv;
 
void print_image(IplImage* img)
    {
    for (int y = 0; y < img->height; y++)
        {
        for (int x = 0; x < img-> width; x++)
            {
            CvScalar s = cvGet2D(img, y, x);
            if (s.val[0] < 10)
                cout << s.val[0] << "   ";
            else if ((s.val[0] >= 10) && (s.val[0] < 100))
                cout << s.val[0] << "  ";
            else if ((s.val[0] >= 10) && (s.val[0] < 100))
                cout << s.val[0] << " ";
            }
        cout << endl;
        }       
    }
 
int hamming_distance(__int64 one, __int64 two)
    {
        int res = 0;
        __int64 mask = 0x0000000000000001;
        __int64 one1;
        __int64 two1;
        for (int i = 0; i < 64; i++)
            {
            one1 = ( one >> i ) & (mask);
            two1 = ( two >> i ) & (mask);
            if (one1 == two1)
                res = res + 1;
            }
        return res;
    }
 
bool hash_eqviv(int distance)
    {
    if (distance < (64 * 100 / EQIV_COEF))
        {
        return true;
        }
    else
        {
        return false;
        }
    }
 
int main (int argc, char** argv)
    {
    IplImage* source;
    IplImage* templ;
 
 
    string src_filename = "E:\\cat.jpg";
    string templ_filename = "E:\\cat2.jpg";
    
 
    char* wnd_src = "src";
    char* wnd_templ = "templ";
    char* wnd_src_8x8 = "src 8x8";
    char* wnd_templ_8x8 = "templ 8x8";
    char* wnd_src_8x8_big = "src 8x8 big";
    char* wnd_templ_8x8_big = "templ 8x8 big";
 
 
    source = cvLoadImage(src_filename.c_str(), CV_LOAD_IMAGE_GRAYSCALE);
    templ = cvLoadImage(templ_filename.c_str(), CV_LOAD_IMAGE_GRAYSCALE);
 
    IplImage* source_8x8 = cvCreateImage(cvSize(8, 8), source->depth, source->nChannels);
    IplImage* templ_8x8 = cvCreateImage(cvSize(8, 8), templ->depth, templ->nChannels);
 
    cvResize(source, source_8x8, 1);
    cvResize(templ, templ_8x8, 1);
 
    print_image(source_8x8);
    cout << endl;
    print_image(templ_8x8);
    cout << endl;
 
    int average_src = 0;
    int average_templ = 0;
 
    for (int y = 0; y < 8; y ++)
        {
        for (int x = 0; x < 8; x++)
            {
            CvScalar a = cvGet2D(source_8x8, y, x);
            average_src = average_src + a.val[0];
            CvScalar t = cvGet2D(templ_8x8, y, x);
            average_templ = average_templ + t.val[0];
            }
        }
    average_src = (int)(average_src / 64);
    cout << "Average src = " << average_src << endl;
    average_templ = (int)(average_templ / 64);
    cout << "Average templ = " << average_templ << endl;
 
    IplImage* source_8x8_bin = cvCreateImage(cvSize(8, 8), source->depth, source->nChannels);
    IplImage* templ_8x8_bin = cvCreateImage(cvSize(8, 8), templ->depth, templ->nChannels);
    
 
    cvCopy(source_8x8, source_8x8_bin);
    cvCopy(templ_8x8, templ_8x8_bin); 
 
    CvScalar bin_1;
    bin_1.val[0] = 1;
    CvScalar bin_0;
    bin_0.val[0] = 0;
 
    for (int y = 0; y < 8; y ++)
        {
        for (int x = 0; x < 8; x++)
            {
            CvScalar a = cvGet2D(source_8x8, y, x);
            if (a.val[0] < average_src)
                {
                cvSet2D(source_8x8_bin,y, x, bin_0);
                }
            else
                {
                cvSet2D(source_8x8_bin,y, x, bin_1);
                }
            CvScalar t = cvGet2D(templ_8x8, y, x);
            if (t.val[0] < average_templ)
                {
                cvSet2D(templ_8x8_bin,y, x, bin_0);
                }
            else
                {
                cvSet2D(templ_8x8_bin,y, x, bin_1);
                }
            }
        }
 
    print_image(source_8x8_bin);
    cout << endl;
    print_image(templ_8x8_bin);
    cout << endl;
 
    __int64 source_hash = 0x0;
    __int64 templ_hash = 0x0;
 
    __int64 mask = 0x0000000000000001;
 
    for (int y = 0; y < 8; y ++)
        {
        for (int x = 0; x < 8; x++)
            {
            CvScalar a = cvGet2D(source_8x8_bin, y, x);
            if (a.val[0] == bin_1.val[0])
                {
                source_hash = source_hash | mask;
                }
            CvScalar t = cvGet2D(templ_8x8_bin, y, x);
            if (t.val[0] == bin_1.val[0])
                {
                templ_hash = templ_hash | mask;
                }
            mask = mask << 1;
            }
        }
 
    cout << "Source hash   = " << hex << source_hash << endl;
    cout << "Template hash = " << hex << templ_hash << endl;
 
    int hash_distance = hamming_distance(source_hash, templ_hash);
    cout << "Hash distance bt Hamming algorithm = " << hash_distance << endl;
 
    IplImage* source_8x8_big = cvCreateImage(cvSize(128, 128),source_8x8->depth, source_8x8->nChannels);
    IplImage* templ_8x8_big = cvCreateImage(cvSize(128, 128),templ_8x8->depth, templ_8x8->nChannels);
    
 
 
    cvResize(source_8x8, source_8x8_big, 1);
    cvResize(templ_8x8, templ_8x8_big, 1);
 
    cvNamedWindow(wnd_src, CV_WINDOW_AUTOSIZE);
    cvNamedWindow(wnd_templ, CV_WINDOW_AUTOSIZE);
    cvNamedWindow(wnd_src_8x8, CV_WINDOW_AUTOSIZE);
    cvNamedWindow(wnd_templ_8x8, CV_WINDOW_AUTOSIZE);
    cvNamedWindow(wnd_src_8x8_big, CV_WINDOW_AUTOSIZE);
    cvNamedWindow(wnd_templ_8x8_big, CV_WINDOW_AUTOSIZE);
 
 
    cvShowImage(wnd_src, source);
    cvShowImage(wnd_templ, templ);
    cvShowImage(wnd_src_8x8, source_8x8);
    cvShowImage(wnd_templ_8x8, templ_8x8);
    cvShowImage(wnd_src_8x8_big, source_8x8_big);
    cvShowImage(wnd_templ_8x8_big, templ_8x8_big);
 
 
    cvWaitKey(0);
 
    return 0;
    }