opencv+树莓PI的基于HOG特征的行人检测

树莓PI远程控制摄像头请参考前文：http://www.cnblogs.com/yuliyang/p/3561209.html

参考：http://answers.opencv.org/question/133/how-do-i-access-an-ip-camera/

http://blog.youtueye.com/work/opencv-hog-peopledetector-trainning.html

 

项目环境：opencv2.8  ,debian, QT

代码：

运行：

yuliyang@debian-yuliyang:~/build-peopledetect-桌面-Debug$ ./peopledetect  /home/yuliyang/OLTbinaries/INRIAPerson/HOG/model_4BiSVMLight.alt

model_4BiSVMLight.alt文件是INRIAPerson行人检测库HOG文件夹下的modle文件

 

#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;
//}

 效果：