#include <fstream>

#include <iostream>

#include <vector>

#include <stdio.h>

#include <string.h>

#include <ctype.h>

#include "opencv2/imgproc/imgproc.hpp"

#include "opencv2/objdetect/objdetect.hpp"

#include "opencv2/highgui/highgui.hpp"

using namespace std;

using namespace cv;

vector<float> load_lear_model(const char* model_file)

{

     vector<float>  detector;

     FILE *modelfl;

     if ((modelfl = fopen (model_file, "rb")) == NULL)

     {

         cout<<"Unable to open the modelfile"<<endl;

         return detector;

     }

     char version_buffer[10];

     if (!fread (&version_buffer,sizeof(char),10,modelfl))

     {

         cout<<"Unable to read version"<<endl;

         return detector;

     }

     if(strcmp(version_buffer,"V6.01"))

     {

        cout<<"Version of model-file does not match version of svm_classify!"<<endl;

        return detector;

     }

     // read version number

     int version = 0;

     if (!fread (&version,sizeof(int),1,modelfl))

     {

         cout<<"Unable to read version number"<<endl;

         return detector;

     }

     if (version < 200)

     {

         cout<<"Does not support model file compiled for light version"<<endl;

         return detector;

      }

     long kernel_type;

     fread(&(kernel_type),sizeof(long),1,modelfl);

     {// ignore these

        long poly_degree;

        fread(&(poly_degree),sizeof(long),1,modelfl);

        double rbf_gamma;

        fread(&(rbf_gamma),sizeof(double),1,modelfl);

        double  coef_lin;

        fread(&(coef_lin),sizeof(double),1,modelfl);

        double coef_const;

        fread(&(coef_const),sizeof(double),1,modelfl);

        long l;

        fread(&l,sizeof(long),1,modelfl);

        char* custom = new char[l];

        fread(custom,sizeof(char),l,modelfl);

        delete[] custom;

    }

    long totwords;

    fread(&(totwords),sizeof(long),1,modelfl);

    {// ignore these

        long totdoc;

        fread(&(totdoc),sizeof(long),1,modelfl);

        long sv_num;

        fread(&(sv_num), sizeof(long),1,modelfl);

    }

    double linearbias = 0.0;

    fread(&linearbias, sizeof(double),1,modelfl);

    if(kernel_type == 0) { /* linear kernel */

        /* save linear wts also */

        double* linearwt = new double[totwords+1];

        int length = totwords;

        fread(linearwt, sizeof(double),totwords+1,modelfl);

        for(int i = 0;i<totwords;i++){

            float term = linearwt[i];

            detector.push_back(term);

        }

        float term = -linearbias;

        detector.push_back(term);

        delete [] linearwt;

    } else {

        cout<<"Only supports linear SVM model files"<<endl;

    }

    fclose(modelfl);

    return detector;

}

void help()

{

    printf(

            "\nDemonstrate the use of the HoG descriptor using\n"

            "  HOGDescriptor::hog.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());\n"

            "Usage:\n"

            "./peopledetect (<image_filename> | <image_list>.txt)\n\n");

}

int main(int argc, char** argv)

{

    VideoCapture cap;

    cap.open("http://192.168.1.102:8001/?action=stream?dummy=param.mjpg");//在浏览器里输入http://192.168.1.102:8001/?action=stream

    cap.set(CV_CAP_PROP_FRAME_WIDTH, 320);

    cap.set(CV_CAP_PROP_FRAME_HEIGHT, 240);

    if (!cap.isOpened())

            return -1;

    Mat img;

    FILE* f = 0;

//    char _filename[1024];

//    if( argc != 3 )

//    {

//        cout<<"ERROR"<<endl;

//        return 0;

//    }

//    img = imread(argv[1]);

//    cap >> img;

//    if( img.data )

//    {

//        strcpy(_filename, argv[1]);

//    }

//    else

//    {

//        f = fopen(argv[1], "rt");

//        if(!f)

//        {

//            fprintf( stderr, "ERROR: the specified file could not be loaded\n");

//            return -1;

//        }

//    }

    HOGDescriptor hog;

    //hog.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());

    vector<float> detector = load_lear_model(argv[1]);

    hog.setSVMDetector(detector);

    namedWindow("people detector", 1);

    while (true)

    {

        cap >> img;

        if (!img.data)

            continue;

        vector<Rect> found, found_filtered;

        hog.detectMultiScale(img, found, 0, Size(4,4), Size(0,0), 1.05, 2);

        size_t i, j;

        for (i=0; i<found.size(); i++)

        {

            Rect r = found[i];

            for (j=0; j<found.size(); j++)

                if (j!=i && (r & found[j])==r)

                    break;

            if (j==found.size())

                found_filtered.push_back(r);

        }

        for (i=0; i<found_filtered.size(); i++)

        {

        Rect r = found_filtered[i];

            r.x += cvRound(r.width*0.1);

        r.width = cvRound(r.width*0.8);

        r.y += cvRound(r.height*0.06);

        r.height = cvRound(r.height*0.9);

        rectangle(img, r.tl(), r.br(), cv::Scalar(0,255,0), 2);

    }

        imshow("people detector", img);

        if (waitKey(20) >= 0)

            break;

    }

//    for(;;)

//    {

//        char* filename = _filename;

//        if(f)

//        {

//            if(!fgets(filename, (int)sizeof(_filename)-2, f))

//                break;

//            //while(*filename && isspace(*filename))

//            //  ++filename;

//            if(filename[0] == '#')

//                continue;

//            int l = strlen(filename);

//            while(l > 0 && isspace(filename[l-1]))

//                --l;

//            filename[l] = '\0';

//            img = imread(filename);

//        }

//        printf("%s:\n", filename);

//        if(!img.data)

//            continue;

//        fflush(stdout);

//        vector<Rect> found, found_filtered;

//        double t = (double)getTickCount();

//        // run the detector with default parameters. to get a higher hit-rate

//        // (and more false alarms, respectively), decrease the hitThreshold and

//        // groupThreshold (set groupThreshold to 0 to turn off the grouping completely).

//        hog.detectMultiScale(img, found, 0, Size(8,8), Size(32,32), 1.05, 2);

//        t = (double)getTickCount() - t;

//        printf("tdetection time = %gms\n", t*1000./cv::getTickFrequency());

//        size_t i, j;

//        for( i = 0; i < found.size(); i++ )

//        {

//            Rect r = found[i];

//            for( j = 0; j < found.size(); j++ )

//                if( j != i && (r & found[j]) == r)

//                    break;

//            if( j == found.size() )

//                found_filtered.push_back(r);

//        }

//        for( i = 0; i < found_filtered.size(); i++ )

//        {

//            Rect r = found_filtered[i];

//            // the HOG detector returns slightly larger rectangles than the real objects.

//            // so we slightly shrink the rectangles to get a nicer output.

//            r.x += cvRound(r.width*0.1);

//            r.width = cvRound(r.width*0.8);

//            r.y += cvRound(r.height*0.07);

//            r.height = cvRound(r.height*0.8);

//            rectangle(img, r.tl(), r.br(), cv::Scalar(0,255,0), 3);

//        }

//        imshow("people detector", img);

//        int c = waitKey(0) & 255;

//        if( c == 'q' || c == 'Q' || !f)

//            break;

//    }

    if(f)

        fclose(f);

    return 0;

}

//#include "opencv2/imgproc/imgproc.hpp"

//#include "opencv2/objdetect/objdetect.hpp"

//#include "opencv2/highgui/highgui.hpp"

//#include <stdio.h>

//#include <string.h>

//#include <ctype.h>

//using namespace cv;

//using namespace std;

//void help()

//{

//    printf(

//            "\nDemonstrate the use of the HoG descriptor using\n"

//            "  HOGDescriptor::hog.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());\n"

//            "Usage:\n"

//            "./peopledetect (<image_filename> | <image_list>.txt)\n\n");

//}

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

//{

//    Mat img;

//    FILE* f = 0;

//    char _filename[1024];

//    if( argc == 1 )

//    {

//        printf("Usage: peopledetect (<image_filename> | <image_list>.txt)\n");

//        return 0;

//    }

//    img = imread(argv[1]);

//    if( img.data )

//    {

//        strcpy(_filename, argv[1]);

//    }

//    else

//    {

//        f = fopen(argv[1], "rt");

//        if(!f)

//        {

//            fprintf( stderr, "ERROR: the specified file could not be loaded\n");

//            return -1;

//        }

//    }

//    HOGDescriptor hog;

//    hog.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());

//    namedWindow("people detector", 1);

//    for(;;)

//    {

//        char* filename = _filename;

//        if(f)

//        {

//            if(!fgets(filename, (int)sizeof(_filename)-2, f))

//                break;

//            //while(*filename && isspace(*filename))

//            //	++filename;

//            if(filename[0] == '#')

//                continue;

//            int l = strlen(filename);

//            while(l > 0 && isspace(filename[l-1]))

//                --l;

//            filename[l] = '\0';

//            img = imread(filename);

//        }

//        printf("%s:\n", filename);

//        if(!img.data)

//            continue;

//        fflush(stdout);

//        vector<Rect> found, found_filtered;

//        double t = (double)getTickCount();

//        // run the detector with default parameters. to get a higher hit-rate

//        // (and more false alarms, respectively), decrease the hitThreshold and

//        // groupThreshold (set groupThreshold to 0 to turn off the grouping completely).

//        hog.detectMultiScale(img, found, 0, Size(8,8), Size(32,32), 1.05, 2);

//        t = (double)getTickCount() - t;

//        printf("tdetection time = %gms\n", t*1000./cv::getTickFrequency());

//        size_t i, j;

//        for( i = 0; i < found.size(); i++ )

//        {

//            Rect r = found[i];

//            for( j = 0; j < found.size(); j++ )

//                if( j != i && (r & found[j]) == r)

//                    break;

//            if( j == found.size() )

//                found_filtered.push_back(r);

//        }

//        for( i = 0; i < found_filtered.size(); i++ )

//        {

//            Rect r = found_filtered[i];

//            // the HOG detector returns slightly larger rectangles than the real objects.

//            // so we slightly shrink the rectangles to get a nicer output.

//            r.x += cvRound(r.width*0.1);

//            r.width = cvRound(r.width*0.8);

//            r.y += cvRound(r.height*0.07);

//            r.height = cvRound(r.height*0.8);

//            rectangle(img, r.tl(), r.br(), cv::Scalar(0,255,0), 3);

//        }

//        imshow("people detector", img);

//        int c = waitKey(0) & 255;

//        if( c == 'q' || c == 'Q' || !f)

//            break;

//    }

//    if(f)

//        fclose(f);

//    return 0;

//}