hogmain.cpp

基于hog人体识别的很好的文章

#include <cv.h>
#include <cvaux.h>
#include <highgui.h>
#include<cxcore.h>
#include <iostream>
#include "ImageStruct.h"
#include <math.h>
#include <fstream>
#include <vector>
using namespace std;

const int DETECT_WIDTH=64;
const int DETECT_HEIGHT=128;
const double PI=3.1415;

struct Point2D
{
	int x;
	int y;
};



void Caculate(int bin,int binarr[][DETECT_WIDTH],float arr[][DETECT_WIDTH],float mag[][DETECT_WIDTH]);

void main()
{
	//crete window to show
	cvNamedWindow("win",CV_WINDOW_AUTOSIZE);

	//load the map
    IplImage *imgOrg=0;
	imgOrg=cvLoadImage("E:\\HOG\\picture\\3.jpg",0);
	if(!imgOrg)
		cout<<"could not load image file "<<endl;
	//show the map
	cvShowImage("win",imgOrg);
	cvWaitKey(100);
	

   
	// output the data of original map to the file
    ofstream  original_mapmax("original_mapmax.txt");
	BwImage imgIF(imgOrg);//constuct a original object
	if(!original_mapmax)
		cerr << "Oops! Unable to save original_mapmax data!"<<endl;
	else
	{
		for(int i=0;i!=imgOrg->height;++i)
		{
		  for(int j=0;j!=imgOrg->width;++j)
    	  original_mapmax<<(int)imgIF[i][j]<<" ";
	      original_mapmax<<endl;
		}
	}


	// caculate the horizonal gradient of map;
	int GradhMax[DETECT_HEIGHT][DETECT_WIDTH]={0};
	for(int hi=0;hi!=DETECT_HEIGHT;++hi)
	{
		for(int hj=1;hj!=DETECT_WIDTH-1;++hj)
		{
            GradhMax[hi][hj]=imgIF[hi][hj+1]-imgIF[hi][hj-1];
		}
	}

    for (hi=0;hi!=DETECT_HEIGHT;++hi)
	{
		GradhMax[hi][0]=0;
		GradhMax[hi][DETECT_WIDTH-1]=0;
	}

	ofstream  gradhMaxOutFile("GradhMax.txt");
	if(!gradhMaxOutFile)
		cerr << "Oops! Unable to save GradhMax data!"<<endl;
	else
	{
		for(int i=0;i!=DETECT_HEIGHT;++i)
		{
		  for(int j=0;j!=DETECT_WIDTH;++j)
    	  gradhMaxOutFile<<GradhMax[i][j]<<" ";
	      gradhMaxOutFile<<endl;
		}
	}



	// caculate the vertical gradient of map;
	int GradvMax[DETECT_HEIGHT][DETECT_WIDTH]={0};
	for(int vi=1;vi!=DETECT_HEIGHT-1;++vi)
	{
		for(int vj=0;vj!=DETECT_WIDTH;++vj)
		{
            GradvMax[vi][vj]=imgIF[vi+1][vj]-imgIF[vi-1][vj];
		}
	}

    for (int vj=0;vj!=DETECT_WIDTH;++vj)
	{
		GradvMax[0][vj]=0;
		GradvMax[DETECT_HEIGHT-1][vj]=0;
	}

	ofstream  gradvMaxOutFile("GradvMax.txt");
	if(!gradvMaxOutFile)
		cerr << "Oops! Unable to save GradhMax data!"<<endl;
	else
	{
		for(int i=0;i!=DETECT_HEIGHT;++i)
		{
		  for(int j=0;j!=DETECT_WIDTH;++j)
    	  gradvMaxOutFile<<GradvMax[i][j]<<" ";
	      gradvMaxOutFile<<endl;
		}
	}


    //cacuclate the magnitude and gradient orient of the map
	float GradMagMax[DETECT_HEIGHT][DETECT_WIDTH]={0.0};
	int GradOrientMax[DETECT_HEIGHT][DETECT_WIDTH]={0};
	for(int mag_i=0;mag_i!=DETECT_HEIGHT;++mag_i)
	
	{
		for(int mag_j=0;mag_j!=DETECT_WIDTH;++mag_j)
		{
			GradMagMax[mag_i][mag_j]=sqrt(GradhMax[mag_i][mag_j]*GradhMax[mag_i][mag_j]+GradvMax[mag_i][mag_j]*GradvMax[mag_i][mag_j]);

			//cacuclate the gradient orient
		    if(GradMagMax[mag_i][mag_j]==0)
              GradOrientMax[mag_i][mag_j]=0;
			else
              GradOrientMax[mag_i][mag_j]=asin((float)GradhMax[mag_i][mag_j]/GradMagMax[mag_i][mag_j])*180/PI;

			if(GradOrientMax[mag_i][mag_j]<0)
				GradOrientMax[mag_i][mag_j]+=180;

			GradOrientMax[mag_i][mag_j]/=20;
            GradOrientMax[mag_i][mag_j]+=1;
		}
    }

	ofstream  gradMagMaxOutFile("GradMagMax.txt");
    ofstream  gradOrientMaxOutFile("GradOrientMax.txt");
	if(!gradMagMaxOutFile )
		cerr << "Oops! Unable to save GradMagMax data!"<<endl;
	else
	{
		for(int i=0;i!=DETECT_HEIGHT;++i)
		{
		  for(int j=0;j!=DETECT_WIDTH;++j)
    	  gradMagMaxOutFile<<GradMagMax[i][j]<<" ";
	      gradMagMaxOutFile<<endl;

          
		}
	}


	if(! gradOrientMaxOutFile)
		cerr <<"Oops! Unable to save GradOrientMax data!"<<endl;
	else
      for(int i=0;i!=DETECT_HEIGHT;++i)
	  {
        for(int j=0;j!=DETECT_WIDTH;++j)
	      gradOrientMaxOutFile<<GradOrientMax[i][j]<<" ";
		  gradOrientMaxOutFile<<endl;
      }


	  float integralIIMagMax[DETECT_HEIGHT][DETECT_WIDTH]={0.0};
	  float integralSMagMax[DETECT_HEIGHT][DETECT_WIDTH]={0.0};
	  float integralBin1Max[DETECT_HEIGHT][DETECT_WIDTH]={0};
	  float integralBin2Max[DETECT_HEIGHT][DETECT_WIDTH]={0};
	  float integralBin3Max[DETECT_HEIGHT][DETECT_WIDTH]={0};
	  float integralBin4Max[DETECT_HEIGHT][DETECT_WIDTH]={0};
	  float integralBin5Max[DETECT_HEIGHT][DETECT_WIDTH]={0};
	  float integralBin6Max[DETECT_HEIGHT][DETECT_WIDTH]={0};
	  float integralBin7Max[DETECT_HEIGHT][DETECT_WIDTH]={0};
	  float integralBin8Max[DETECT_HEIGHT][DETECT_WIDTH]={0};
	  float integralBin9Max[DETECT_HEIGHT][DETECT_WIDTH]={0};

	  //pay more attention in a[][]  the previous place of a[i][0] is a[i-1][width],so a[i][-1] no sense
	 /* for(int i=0;i!=DETECT_HEIGHT;++i)  
        integralSMagMax[i][-1]=0;*/
	  for(int j=0;j!=DETECT_WIDTH;++j)
	    integralIIMagMax[-1][j]=0;

	   for(int i=0;i!=DETECT_HEIGHT;++i)
	   {
		  for(int j=0;j!=DETECT_WIDTH;++j) 
		 {
		  if(j==0)
		  {
			  integralSMagMax[i][j]=GradMagMax[i][j];
		  }
		  else
		  integralSMagMax[i][j]=integralSMagMax[i][j-1]+GradMagMax[i][j];
          integralIIMagMax[i][j]=integralIIMagMax[i-1][j]+integralSMagMax[i][j];
		  
		 }
	
	   }

	   //caculate the different bin integral map
	   Caculate(1,GradOrientMax, integralBin1Max,GradMagMax);
       Caculate(2,GradOrientMax, integralBin2Max,GradMagMax);
	   Caculate(3,GradOrientMax, integralBin3Max,GradMagMax);
	   Caculate(4,GradOrientMax, integralBin4Max,GradMagMax);
	   Caculate(5,GradOrientMax, integralBin5Max,GradMagMax);
	   Caculate(6,GradOrientMax, integralBin6Max,GradMagMax);
	   Caculate(7,GradOrientMax, integralBin7Max,GradMagMax);
	   Caculate(8,GradOrientMax, integralBin8Max,GradMagMax);
	   Caculate(9,GradOrientMax, integralBin9Max,GradMagMax);

        //output the result of integral magnitude of map 
    	ofstream  integralMaxOutFile("integralMax.txt");
	    if(!integralMaxOutFile)
		    cerr << "Oops! Unable to save integralMax data!"<<endl;
    	else
		{
		  for(int i=0;i!=DETECT_HEIGHT;++i)
		{
		  for(int j=0;j!=DETECT_WIDTH;++j)

    	  integralMaxOutFile<<integralIIMagMax[i][j]<<" ";
	      integralMaxOutFile<<endl;  
		 }
		}

		//output the result of integral of each bin
		//output bin1 integral
		ofstream  integralBin1outFile("integralbin1Max.txt");
	    if(!integralBin1outFile)
		    cerr << "Oops! Unable to save integralbin1Max data!"<<endl;
    	else
		{
		  for(int i=0;i!=DETECT_HEIGHT;++i)
		{
		  for(int j=0;j!=DETECT_WIDTH;++j)

    	  integralBin1outFile<<integralBin1Max[i][j]<<" ";
	      integralBin1outFile<<endl;  
		 }
		}

        //output bin2 integral
        ofstream  integralBin2outFile("integralbin2Max.txt");
	    if(!integralBin2outFile)
		    cerr << "Oops! Unable to save integralbin2Max data!"<<endl;
    	else
		{
		  for(int i=0;i!=DETECT_HEIGHT;++i)
		{
		  for(int j=0;j!=DETECT_WIDTH;++j)

    	  integralBin2outFile<<integralBin2Max[i][j]<<" ";
	      integralBin2outFile<<endl;  
		 }
		}

		//output bin3 integral
		ofstream  integralBin3outFile("integralbin3Max.txt");
	    if(!integralBin3outFile)
		    cerr << "Oops! Unable to save integralbin3Max data!"<<endl;
    	else
		{
		  for(int i=0;i!=DETECT_HEIGHT;++i)
		{
		  for(int j=0;j!=DETECT_WIDTH;++j)

    	  integralBin3outFile<<integralBin3Max[i][j]<<" ";
	      integralBin3outFile<<endl;  
		 }
		}

		//output bin4 integral

		ofstream  integralBin4outFile("integralbin4Max.txt");
	    if(!integralBin4outFile)
		    cerr << "Oops! Unable to save integralbin4Max data!"<<endl;
    	else
		{
		  for(int i=0;i!=DETECT_HEIGHT;++i)
		{
		  for(int j=0;j!=DETECT_WIDTH;++j)

    	  integralBin4outFile<<integralBin4Max[i][j]<<" ";
	      integralBin4outFile<<endl;  
		 }
		}

		//output bin5 integral