OpenCV OpenGL手写字符识别

另外一篇文章地址：这个比较详细，但是程序略显简单，现在这个程序是比较复杂的

http://blog.csdn.net/wangyaninglm/article/details/17091901

整个项目下载地址：

http://download.csdn.net/detail/wangyaninglm/8244549

实现效果：

Finger.h

#ifndef __TOUCHSCREEN_FINGER__
#define __TOUCHSCREEN_FINGER__

#include <cxcore.h>
#include <vector>

class Finger
{
public:
	Finger()
	{
		area = 0.0f;	
		w=h=0;
	};
public:
	CvPoint center;
	float area;
	float w;
	float h;
};


//typedef std::vector<Finger> FingerTrack;	


class FingerTrack
{
public:
	FingerTrack()
	{
		states=0;
		lostCount =0;
	}
	std::vector<Finger> track;
	int states;
	int lostCount;

};

#endif 

MachineLearning.h

#include <cxcore.h>
#include <cv.h>
#include <ml.h>
#include <string>
using namespace std ;
class MachineLearning
{
	enum TraningMethod 
	{
		RandomTrees,
		Boosting,
		NeuralNetworks,
		SVM
	};

public:
	bool getCrossFeature(IplImage *img,float featureData[]);
	bool predict(char &shape_type,float featureData[]);
	bool load(const char *training_filename);
	bool train(const  char *data_filename,const  char *save_filename);
	MachineLearning(void);
	void ExtractDFT(float pcadata[],const int featureData[],const int &dataWidth,const int &DFTwidth);
	int DataCount;

private:
	static const int CROSS_COLS = 50;
	static const int CROSS_ROWS = 50;
	void getCrossFeatureData(IplImage *img_cross,int featureData[],const int &cols,const int &rows );
	void getDistanceFeatureData(IplImage *img_cross,int featureData[],const int &cols,const int &rows );
	void getCrossCenter(IplImage *img_cross,int &cx,int &cy);
	void getCrossSpecifyArea(IplImage *img_cross,CvRect &specifie_rect);
	void ExtractPCA(float pcadata[],const int featureData[],const int &dataWidth );

	bool is_load_training_model; 
	TraningMethod  traning_method;
	int read_num_class_data( const char* filename, int var_count,CvMat** data, CvMat** responses);
	int build_rtrees_classifier(const char* data_filename,const char* filename_to_save,const char* filename_to_load);
	int build_boost_classifier( char* data_filename,char* filename_to_save, char* filename_to_load );
	int build_mlp_classifier( char* data_filename,char* filename_to_save, char* filename_to_load );
	int build_svm_classifier( char* data_filename,char* filename_to_save, char* filename_to_load );

	CvRTrees forest;
	int predict_rtrees_classifier(CvMat *sample_data,char &shape_type);



};

machinelearning.cpp

/*************************************************
  Copyright (C)
  File name:      
  Author:				Hardy
  Version:				1.0
  Date:					2007－3－5
  Description:			模式识别部分,提取特征数据，训练模型，预测结果
  Others:         
  Function List:      
  History:        
    1. Date:
       Author:
       Modification:
    2. ...
************************************************/

#include "stdafx.h"
#include "MachineLearning.h"
#include <highgui.h>
#include <iostream>
#include <fstream>


MachineLearning::MachineLearning(void)
{
	is_load_training_model = false;
	traning_method = RandomTrees;
}

bool MachineLearning::getCrossFeature(IplImage *img,float pcaData[])
/*************************************************
  Function:        
  Description:  样本数据载入		
  Date:			2007－3－5
  Author:   
  Input:                         
  Output:         
  Return:         
  Others:          
*************************************************/
{

	assert(img);

	////计算图形所在矩形
	//int cx,cy;
	//getCrossCenter(img,cx,cy);
	//CvRect roiRect;
	//getCrossSpecifyArea(img,roiRect);

	//assert(roiRect.x>0);
	//assert(roiRect.y>0);
	//assert(roiRect.height>0 && roiRect.height < img->width);
	//assert(roiRect.width>0 && roiRect.width < img->width );
	//cvSetImageROI(img,roiRect);


	//IplImage *img_copy = cvCreateImage(cvSize(100,100) , 8, 1 );
	//img_copy->origin = img->origin;
	//cvZero(img_copy);
	//cvResize(img,img_copy,CV_INTER_NN);
	//cvResetImageROI(img);


	//计算形心
	int cx,cy;
	getCrossCenter(img,cx,cy);

	assert(cx<img->width);
	assert(cx>0);
	assert(cy<img->height);
	assert(cy>0);

	int shift_x = img->width/2 - cx;
	int shift_y = img->height/2 - cy;


	IplImage *img_copy = cvCreateImage(cvGetSize(img) , 8, 1 );
	img_copy->origin = img->origin;
	cvZero(img_copy);

	//移动图形到中心
	for(int i = 0; i<img->width;i++)
	{
		for(int j = 0; j<img->height;j++)
		{
			CvScalar c = cvGetAt(img,j,i); 
			int v = (int)c.val[0];
			if(v==255)
			{
				int nj=j+shift_y;
				int ni=i+shift_x;
				if(nj<img->height && ni<img->width)
					if(nj>=0 && ni>=0)
						cvSet2D(img_copy,nj,ni,c);
			}
		}
	}

	//计算密度特征数据--------------
	//int featureData[CROSS_ROWS + CROSS_COLS];
	//memset(featureData,-1,sizeof(featureData));
	//getCrossFeatureData(img_copy,featureData,CROSS_COLS,CROSS_ROWS);
	////std::cout<<"--------------------------------------------"<<std::endl;
	////cvShowImage("WIN1",img_copy);
	////cvWaitKey(0);	
	//float CrossData[10];
	//ExtractPCA(CrossData,featureData,CROSS_COLS+CROSS_ROWS);
	//
	
	//计算距离特征数据	
	int featureDisData[2*CROSS_ROWS + CROSS_COLS];
	memset(featureDisData,-1,sizeof(featureDisData));	
	getDistanceFeatureData(img_copy,featureDisData,CROSS_COLS,CROSS_ROWS);
	float DistanceData[10];
	ExtractPCA(DistanceData,featureDisData,CROSS_COLS+2*CROSS_ROWS);

	//合并特征数据
	//for(int i=0;i<5;i++) pcaData[i] = CrossData[i];
	//for(int i=5;i<10;i++) pcaData[i] = DistanceData[i-5];
	for(int i=0;i<10;i++) pcaData[i] = DistanceData[i];

	
	cvReleaseImage(&img_copy);

	return true;
}

void MachineLearning::getCrossFeatureData(IplImage *img_cross,int featureData[],const int &cols,const int &rows)
/*************************************************
  Function:        
  Description:  穿线得到特征数据		
  Date:			2007－3－5
  Author:   
  Input:                         
  Output:         
  Return:         
  Others:          
*************************************************/
{
	const int CROSS_VALID_LENGTH = 6; //在6个象素内不计算穿越数目,避免噪音
	CvScalar c;

	for(int cross_index=0;cross_index<rows;cross_index++)
	{
		int y = (int)(img_cross->height*((float)cross_index/rows)); //按照比例决定位置

		int cross_count = 0;
		int pre_v = -1;
		int pre_x = 0;
		for(int x =0;x<img_cross->width;x++)
		{			 
			c = cvGetAt(img_cross,y,x); 
			int v = (int)c.val[0];
			if(pre_v==255 && v==0) 
				if((x-pre_x)>CROSS_VALID_LENGTH)
				{
					cross_count++;
					pre_x = x;
				}
			pre_v = v;
			
		}

		//cout<<cross_count<<",";		
		featureData[cross_index] = cross_count;
		
	}

	for(int cross_index=0;cross_index<cols;cross_index++)
	{
		int x = (int)(img_cross->width*((float)cross_index/cols));

		int cross_count = 0;
		int pre_v = -1;
		int pre_y = 0;
		for(int y =0;y<img_cross->height;y++)
		{
			
			c = cvGetAt(img_cross,y,x); 
			int v = (int)c.val[0];
			if(pre_v==255 && v==0)
				if((y-pre_y)>CROSS_VALID_LENGTH)
				{
					cross_count++;
					pre_y = y;
				}

			pre_v = v;
		}

		//cout<<cross_count<<",";		
		featureData[rows+cross_index] = cross_count;		
	} 


}

void MachineLearning::getDistanceFeatureData(IplImage *img_cross,int featureData[],const int &cols,const int &rows)
/*************************************************
  Function:        
  Description:  穿线得到距离特征数据		
  Date:			2007－3－9
  Author:   
  Input:                         
  Output:         
  Return:         
  Others:          
*************************************************/
{	

	CvScalar c;

	//从左向右穿线
	for(int cross_index=0;cross_index<rows;cross_index++)
	{
		int y = (int)(img_cross->height*((float)cross_index/rows)); //按照比例决定位置
		int meet_x = 0;
		for(int x =0;x<img_cross->width;x++)
		{			 
			c = cvGetAt(img_cross,y,x); 
			int v = (int)c.val[0];
			if(v==255) 
			{
				meet_x = x;			
				break;
			}
		}
		//cout<<meet_x<<",";		
		featureData[cross_index] = meet_x;		
	}

	//从右向左穿线
	for(int cross_index=rows;cross_index<2*rows;cross_index++)
	{
		int y = (int)(img_cross->height*((float)(cross_index-rows)/rows)); //按照比例决定位置
		int meet_x = 0;
		for(int x =(img_cross->width-1);x>-1;x--)
		{			 
			c = cvGetAt(img_cross,y,x); 
			int v = (int)c.val[0];
			if(v==255) 
			{
				meet_x = x;			
				break;
			}			
		}
		//cout<<meet_x<<",";
		featureData[cross_index] = meet_x;		
	}

	//从下向上穿线
	for(int cross_index=0;cross_index<cols;cross_index++)
	{
		int x = (int)(img_cross->width*((float)cross_index/cols));

		int meet_y = 0;
		for(int y =(img_cross->height-1);y>-1;y--)
		{
			
			c = cvGetAt(img_cross,y,x); 
			int v = (int)c.val[0];
			if(v==255) 
			{
				meet_y = y;
				break;
			}
		}
		//cout<<meet_y<<",";		
		featureData[2*rows+cross_index] = meet_y;		
	} 


}

void MachineLearning::getCrossSpecifyArea(IplImage *img,CvRect &specifie_rect)
/*************************************************
  Function:        
  Description:  获得图像矩形		
  Date:			2007－3－7
  Author:   
  Input:                         
  Output:         
  Return:         
  Others:          
*************************************************/
{
	CvRect res_rect = cvRect(0,0,0,0);
	const int fix =0;
	CvMemStorage*  mt_storage  =  cvCreateMemStorage(0);
	CvSeq* mt_contour = NULL;
	int ApproxCount = 2; //轮廓优化等级	
	IplImage *frame_copy = cvCreateImage(cvGetSize(img) , 8, 1 );
	frame_copy->origin = img->origin;
	cvCopy(img,frame_copy,0);
	cvFindContours( frame_copy, mt_storage, &mt_contour, sizeof(CvContour),
		CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0) );
	if(mt_contour)
	{
		CvSeqReader reader;
		int i;
		CvPoint left_top_pt=cvPoint(img->width,img->height);
		CvPoint right_bottom_pt=cvPoint(0,0);
		
		CvPoint pt;
		CvSeq *contour2 = mt_contour;

		for (; contour2 != NULL; contour2 = contour2->h_next)
		{
			cvStartReadSeq(contour2, &reader);
			int N = contour2->total;
			if(N<10) continue;

			for (i = 0; i < N; i++)
			{
				CV_READ_SEQ_ELEM(pt, reader);
				if(left_top_pt.x>pt.x)left_top_pt.x = pt.x;
				if(left_top_pt.y>pt.y)left_top_pt.y = pt.y;
				if(right_bottom_pt.x<pt.x)right_bottom_pt.x = pt.x;
				if(right_bottom_pt.y<pt.y)right_bottom_pt.y = pt.y;

			}
			res_rect = cvRect(abs(left_top_pt.x-fix),abs(left_top_pt.y-fix),(right_bottom_pt.x-left_top_pt.x+2*fix),(right_bottom_pt.y-left_top_pt.y+2*fix));
			specifie_rect = res_rect;
			break;
		}
	}

	cvClearMemStorage(mt_storage);
	cvReleaseImage(&frame_copy);
}

void MachineLearning::getCrossCenter(IplImage *img,int &cx,int &cy)
/*************************************************
  Function:        
  Description:  获得图像平移到中心		
  Date:			2007－3－5
  Author:   
  Input:                         
  Output:         
  Return:         
  Others:          
*************************************************/
{
	CvMemStorage*  mt_storage  =  cvCreateMemStorage(0);
	CvSeq* mt_contour = NULL;
	int ApproxCount = 2; //轮廓优化等级	
	IplImage *frame_copy = cvCreateImage(cvGetSize(img) , 8, 1 );
	frame_copy->origin = img->origin;
	cvCopy(img,frame_copy,0);
	cvFindContours( frame_copy, mt_storage, &mt_contour, sizeof(CvContour),
		CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0) );
	if(mt_contour)
	{
		CvSeqReader reader;
		int i;
		int total_x = 0;
		int total_y = 0;
		
		CvPoint pt;
		CvSeq *contour2 = mt_contour;

		for (; contour2 != NULL; contour2 = contour2->h_next)
		{
			cvStartReadSeq(contour2, &reader);
			int N = contour2->total;
			if(N<10) continue;

			for (i = 0; i < N; i++)
			{
				CV_READ_SEQ_ELEM(pt, reader);
				total_x += pt.x;
				total_y += pt.y;
			}
			cx = total_x/N;
			cy = total_y/N;
			break;
		}
	}
	cvReleaseMemStorage(&mt_storage);
	cvReleaseImage(&frame_copy);
}

void MachineLearning::ExtractPCA(float pcadata[],const int featureData[],const int &dataWidth )
/*************************************************
  Function:        
  Description:  采用fourier transfer 得到降维的数据		
  Date:			2007－3－5
  Author:   
  Input:                         
  Output:         
  Return:         
  Others:          
*************************************************/
{
			
	//int dataWidth = cols + rows;		
	//CvMat* pData = cvCreateMat(2,dataWidth, CV_32FC1);
	//for(int i = 0; i < dataWidth; i++)
	//{
	//	cvSet2D(pData, 0, i,cvRealScalar(i));				
	//	cvSet2D(pData, 1, i,cvRealScalar(featureData[i]));				
	//}

	//CvMat* pMean = cvCreateMat(2, dataWidth, CV_32FC1);
	//CvMat* pEigVals = cvCreateMat(2, dataWidth, CV_32FC1);
	//CvMat* pEigVecs = cvCreateMat(2, dataWidth, CV_32FC1);

	//cvCalcPCA(pData, pMean, pEigVals, pEigVecs, CV_PCA_DATA_AS_ROW );

	//float pp[100];
	//memcpy(pp,pEigVals->data.fl,100 );
	//memcpy(pp,pEigVecs->data.fl,100 );
	//memcpy(pp,pMean->data.fl,100 );
	
	CvMat* s = cvCreateMat(1,dataWidth,CV_32FC1);
	memcpy(s->data.i,featureData,sizeof(featureData));
	for(int i=0;i<dataWidth;i++)
			cvSetReal2D(s,0,i,featureData[i]);
 
	//for(int i=0;i<dataWidth;i++)
	//		printf("%6.2f\t",cvGetReal2D(s,0,i));
	//printf("\n");

	CvMat* d = cvCreateMat(1,dataWidth,CV_32FC1);

	cvDFT(s,d,CV_DXT_FORWARD|CV_DXT_SCALE);

	//for(int i=0;i<dataWidth;i++)
	//		printf("%6.2f\t",cvGetReal2D(d,0,i));
	//printf("\n");

	for(int i=0;i<10;i++)
	{
		pcadata[i] = (float)cvGetReal2D(d,0,i); 
	}

	cvReleaseMat(&s);
	cvReleaseMat(&d);
}



void MachineLearning::ExtractDFT(float pcadata[],const int featureData[],const int &dataWidth,const int &DFTwidth )
/*************************************************
  Function:        
  Description:  采用fourier transfer 得到降维的数据		
  Date:			2007－3－5
  Author:   
  Input:                         
  Output:         
  Return:         
  Others:          
*************************************************/
{
			

	
	CvMat* s = cvCreateMat(1,dataWidth,CV_32FC1);
	memcpy(s->data.i,featureData,sizeof(featureData));
	for(int i=0;i<dataWidth;i++)
			cvSetReal2D(s,0,i,featureData[i]);
 
	//for(int i=0;i<dataWidth;i++)
	//		printf("%6.2f\t",cvGetReal2D(s,0,i));
	//printf("\n");

	CvMat* d = cvCreateMat(1,dataWidth,CV_32FC1);

	cvDFT(s,d,CV_DXT_FORWARD|CV_DXT_SCALE);

	//for(int i=0;i<dataWidth;i++)
	//		printf("%6.2f\t",cvGetReal2D(d,0,i));
	//printf("\n");

	for(int i=0;i<DFTwidth;i++)
	{
		pcadata[i] = (float)cvGetReal2D(d,0,i); 
	}

	cvReleaseMat(&s);
	cvReleaseMat(&d);
}



int MachineLearning::read_num_class_data( const char* filename, int var_count,CvMat** data, CvMat** responses )
{
    const int M = 1024;
    FILE* f = fopen( filename, "rt" );
    CvMemStorage* storage;
    CvSeq* seq;
    char buf[M+2];
    float* el_ptr;
    CvSeqReader reader;
    int i, j;

    if( !f )
        return 0;

    el_ptr = new float[var_count+1];
    storage = cvCreateMemStorage();
    seq = cvCreateSeq( 0, sizeof(*seq), (var_count+1)*sizeof(float), storage );

    for(;;)
    {
        char* ptr;
        if( !fgets( buf, M, f ) || !strchr( buf, ',' ) )
            break;
        el_ptr[0] = buf[0];
        ptr = buf+2;
        for( i = 1; i <= var_count; i++ )
        {
            int n = 0;
            sscanf( ptr, "%f%n", el_ptr + i, &n );
            ptr += n + 1;
        }
        if( i <= var_count )
            break;
        cvSeqPush( seq, el_ptr );
    }
    fclose(f);

    *data = cvCreateMat( seq->total, var_count, CV_32F );
    *responses = cvCreateMat( seq->total, 1, CV_32F );

    cvStartReadSeq( seq, &reader );

    for( i = 0; i < seq->total; i++ )
    {
        const float* sdata = (float*)reader.ptr + 1;
        float* ddata = data[0]->data.fl + var_count*i;
        float* dr = responses[0]->data.fl + i;

        for( j = 0; j < var_count; j++ )
            ddata[j] = sdata[j];
        *dr = sdata[-1];
        CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
    }

    cvReleaseMemStorage( &storage );
    delete el_ptr;
    return 1;
}

int MachineLearning::build_rtrees_classifier(const char* data_filename,
  const char* filename_to_save, const char* filename_to_load )
{
    CvMat* data = 0;
    CvMat* responses = 0;
    CvMat* var_type = 0;
    CvMat* sample_idx = 0;

	


    // Create or load Random Trees classifier
    if( filename_to_load )
    {
        // load classifier from the specified file
        forest.load( filename_to_load );
        if( forest.get_tree_count() == 0 )
        {
            printf( "Could not read the classifier %s\n", filename_to_load );
            return -1;
        }
        printf( "The classifier %s is loaded.\n", data_filename );
    }
    else
    {
		int ok = read_num_class_data( data_filename, DataCount, &data, &responses );
		int nsamples_all = 0, ntrain_samples = 0;
		int i = 0;
		double train_hr = 0, test_hr = 0;
		
		CvMat* var_importance = 0;

		if( !ok )
		{
			printf( "Could not read the database %s\n", data_filename );
			return -1;
		}

		printf( "The database %s is loaded.\n", data_filename );
		nsamples_all = data->rows;
		ntrain_samples = (int)(nsamples_all*0.8);

		int ntrain_tests = -1;

		// create classifier by using <data> and <responses>
        printf( "Training the classifier ...");

        // 1. create type mask
        var_type = cvCreateMat( data->cols + 1, 1, CV_8U );
        cvSet( var_type, cvScalarAll(CV_VAR_ORDERED) );
        cvSetReal1D( var_type, data->cols, CV_VAR_CATEGORICAL );
		//00000000001

		// 2. create sample_idx
		sample_idx = cvCreateMat( 1, nsamples_all, CV_8UC1 );
		{
			CvMat mat;
			cvGetCols( sample_idx, &mat, 0, nsamples_all );
			cvSet( &mat, cvRealScalar(1) );

			for(int i=0;i<nsamples_all;i++)
			{
				if((i%5)==0) 
				{
					cvSet2D(sample_idx,0,i,cvRealScalar(0));
					ntrain_tests++;
				}
			}
		}
		
	
		// 3. train classifier
		forest.train( data, CV_ROW_SAMPLE, responses, 0, sample_idx, var_type, 0,
			CvRTParams(10,10,0,false,15,0,true,4,100,0.01f,CV_TERMCRIT_ITER));
		printf( "\n");

		// compute prediction error on train and test data
		int test_count=0;
		int train_count=0;
		for(int i = 0; i < nsamples_all; i++ )
		{
			double r;
			CvMat sample;
			cvGetRow( data, &sample, i );

			r = forest.predict( &sample );
			double abs_r = fabs((float)r - responses->data.fl[i]) <= FLT_EPSILON ? 1.0 : 0.0;

			if(abs_r < FLT_EPSILON)
			{
				printf( "data error with lines %d '%c' %f \n",i,(char)responses->data.fl[i],fabs((float)r - responses->data.fl[i])); 
			}

			if((i%5)==0)
			{
				test_hr += abs_r;	
			}
			else
			{
				train_hr += abs_r; 
			}
				
		}

		test_hr /= (double)(ntrain_tests);
		train_hr /= (double)(nsamples_all-ntrain_tests);
		printf( "Recognition rate: train = %.1f%%, test = %.1f%%\n",
			train_hr*100., test_hr*100. );

		//printf( "Number of trees: %d\n", forest.get_tree_count() );
	}






    //// Save Random Trees classifier to file if needed
    if( filename_to_save )
        forest.save( filename_to_save );
	//forest.save("..//data//rTreeResult.xml");

    cvReleaseMat( &sample_idx );
    cvReleaseMat( &var_type );
    cvReleaseMat( &data );
    cvReleaseMat( &responses );

    return 0;
}


int MachineLearning::build_boost_classifier( char* data_filename,
    char* filename_to_save, char* filename_to_load )
{
    const int class_count = 3;
    CvMat* data = 0;
    CvMat* responses = 0;
    CvMat* var_type = 0;
    CvMat* temp_sample = 0;
    CvMat* weak_responses = 0;

    int ok = read_num_class_data( data_filename, 13, &data, &responses );
    int nsamples_all = 0, ntrain_samples = 0;
    int var_count;
    int i, j, k;
    double train_hr = 0, test_hr = 0;
    CvBoost boost;

    if( !ok )
    {
        printf( "Could not read the database %s\n", data_filename );
        return -1;
    }

    printf( "The database %s is loaded.\n", data_filename );
    nsamples_all = data->rows;
    ntrain_samples = (int)(nsamples_all*0.9);
    var_count = data->cols;

    // Create or load Boosted Tree classifier
    if( filename_to_load )
    {
        // load classifier from the specified file
        boost.load( filename_to_load );
        ntrain_samples = 0;
        if( !boost.get_weak_predictors() )
        {
            printf( "Could not read the classifier %s\n", filename_to_load );
            return -1;
        }
        printf( "The classifier %s is loaded.\n", data_filename );
    }
    else
    {
        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        //
        // As currently boosted tree classifier in MLL can only be trained
        // for 2-class problems, we transform the training database by
        // "unrolling" each training sample as many times as the number of
        // classes (26) that we have.
        //
        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

        CvMat* new_data = cvCreateMat( ntrain_samples*class_count, var_count + 1, CV_32F );
        CvMat* new_responses = cvCreateMat( ntrain_samples*class_count, 1, CV_32S );

        // 1. unroll the database type mask
        printf( "Unrolling the database...\n");
        for( i = 0; i < ntrain_samples; i++ )
        {
            float* data_row = (float*)(data->data.ptr + data->step*i);
            for( j = 0; j < class_count; j++ )
            {
                float* new_data_row = (float*)(new_data->data.ptr +
                                new_data->step*(i*class_count+j));
                for( k = 0; k < var_count; k++ )
                    new_data_row[k] = data_row[k];
                new_data_row[var_count] = (float)j;
                new_responses->data.i[i*class_count + j] = responses->data.fl[i] == j+'A';
            }
        }

        // 2. create type mask
        var_type = cvCreateMat( var_count + 2, 1, CV_8U );
        cvSet( var_type, cvScalarAll(CV_VAR_ORDERED) );
        // the last indicator variable, as well
        // as the new (binary) response are categorical
        cvSetReal1D( var_type, var_count, CV_VAR_CATEGORICAL );
        cvSetReal1D( var_type, var_count+1, CV_VAR_CATEGORICAL );



        // 3. train classifier
        printf( "Training the classifier (may take a few minutes)...");
        boost.train( new_data, CV_ROW_SAMPLE, new_responses, 0, 0, var_type, 0,
            CvBoostParams(CvBoost::REAL, 100, 0.95, 5, false, 0 ));
        cvReleaseMat( &new_data );
        cvReleaseMat( &new_responses );
        printf("\n");
    }

    temp_sample = cvCreateMat( 1, var_count + 1, CV_32F );
    weak_responses = cvCreateMat( 1, boost.get_weak_predictors()->total, CV_32F ); 

    // compute prediction error on train and test data
    for( i = 0; i < nsamples_all; i++ )
    {
        int best_class = 0;
        double max_sum = -DBL_MAX;
        double r;
        CvMat sample;
        cvGetRow( data, &sample, i );
        for( k = 0; k < var_count; k++ )
            temp_sample->data.fl[k] = sample.data.fl[k];

        for( j = 0; j < class_count; j++ )
        {
            temp_sample->data.fl[var_count] = (float)j;
            boost.predict( temp_sample, 0, weak_responses );
            double sum = cvSum( weak_responses ).val[0];
            if( max_sum < sum )
            {
                max_sum = sum;
                best_class = j + 'A';
            }
        }

        r = fabs(best_class - responses->data.fl[i]) < FLT_EPSILON ? 1 : 0;

        if( i < ntrain_samples )
            train_hr += r;
        else
            test_hr += r;
    }

    test_hr /= (double)(nsamples_all-ntrain_samples);
    train_hr /= (double)ntrain_samples;
    printf( "Recognition rate: train = %.1f%%, test = %.1f%%\n",
            train_hr*100., test_hr*100. );

    printf( "Number of trees: %d\n", boost.get_weak_predictors()->total );

    // Save classifier to file if needed
    if( filename_to_save )
        boost.save( filename_to_save );

    cvReleaseMat( &temp_sample );
    cvReleaseMat( &weak_responses );
    cvReleaseMat( &var_type );
    cvReleaseMat( &data );
    cvReleaseMat( &responses );

    return 0;
}


int MachineLearning::build_mlp_classifier( char* data_filename,
    char* filename_to_save, char* filename_to_load )
{
    const int class_count = 3;
    CvMat* data = 0;
    CvMat train_data;
    CvMat* responses = 0;
    CvMat* mlp_response = 0;

    int ok = read_num_class_data( data_filename, 13, &data, &responses );
    int nsamples_all = 0, ntrain_samples = 0;
    int i, j;
    double train_hr = 0, test_hr = 0;
    CvANN_MLP mlp;

    if( !ok )
    {
        printf( "Could not read the database %s\n", data_filename );
        return -1;
    }

    printf( "The database %s is loaded.\n", data_filename );
    nsamples_all = data->rows;
    ntrain_samples = (int)(nsamples_all*0.9);

    // Create or load MLP classifier
    if( filename_to_load )
    {
        // load classifier from the specified file
        mlp.load( filename_to_load );
        ntrain_samples = 0;
        if( !mlp.get_layer_count() )
        {
            printf( "Could not read the classifier %s\n", filename_to_load );
            return -1;
        }
        printf( "The classifier %s is loaded.\n", data_filename );
    }
    else
    {
        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        //
        // MLP does not support categorical variables by explicitly.
        // So, instead of the output class label, we will use
        // a binary vector of <class_count> components for training and,
        // therefore, MLP will give us a vector of "probabilities" at the
        // prediction stage
        //
        // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

        CvMat* new_responses = cvCreateMat( ntrain_samples, class_count, CV_32F );

        // 1. unroll the responses
        printf( "Unrolling the responses...\n");
        for( i = 0; i < ntrain_samples; i++ )
        {
            int cls_label = cvRound(responses->data.fl[i]) - 'A';
            float* bit_vec = (float*)(new_responses->data.ptr + i*new_responses->step);
            for( j = 0; j < class_count; j++ )
                bit_vec[j] = 0.f;
            bit_vec[cls_label] = 1.f;
        }
        cvGetRows( data, &train_data, 0, ntrain_samples );

        // 2. train classifier
        int layer_sz[] = { data->cols, 100, 100, class_count };
        CvMat layer_sizes =
            cvMat( 1, (int)(sizeof(layer_sz)/sizeof(layer_sz[0])), CV_32S, layer_sz );
        mlp.create( &layer_sizes );
        printf( "Training the classifier (may take a few minutes)...");
        mlp.train( &train_data, new_responses, 0, 0,
            CvANN_MLP_TrainParams(cvTermCriteria(CV_TERMCRIT_ITER,300,0.01),
            CvANN_MLP_TrainParams::RPROP,0.01));
        cvReleaseMat( &new_responses );
        printf("\n");
    }

    mlp_response = cvCreateMat( 1, class_count, CV_32F );

    // compute prediction error on train and test data
    for( i = 0; i < nsamples_all; i++ )
    {
        int best_class;
        CvMat sample;
        cvGetRow( data, &sample, i );
        CvPoint max_loc = {0,0};
        mlp.predict( &sample, mlp_response );
        cvMinMaxLoc( mlp_response, 0, 0, 0, &max_loc, 0 );
        best_class = max_loc.x + 'A';

        int r = fabs((double)best_class - responses->data.fl[i]) < FLT_EPSILON ? 1 : 0;

        if( i < ntrain_samples )
            train_hr += r;
        else
            test_hr += r;
    }

    test_hr /= (double)(nsamples_all-ntrain_samples);
    train_hr /= (double)ntrain_samples;
    printf( "Recognition rate: train = %.1f%%, test = %.1f%%\n",
            train_hr*100., test_hr*100. );

    // Save classifier to file if needed
    if( filename_to_save )
        mlp.save( filename_to_save );

    cvReleaseMat( &mlp_response );
    cvReleaseMat( &data );
    cvReleaseMat( &responses );

    return 0;
}

int MachineLearning::build_svm_classifier( char* data_filename,
    char* filename_to_save, char* filename_to_load )
{

    CvMat* data = 0;
    //CvMat train_data;
    CvMat* responses = 0;
    CvMat* mlp_response = 0;
	CvMat* var_type = 0;
    CvMat* sample_idx = 0;

    int ok = read_num_class_data( data_filename, 10, &data, &responses );

	float kk[100];
	memcpy(kk,data->data.fl,100);
    int nsamples_all = 0, ntrain_samples = 0;
    int i;
    double train_hr = 0, test_hr = 0;
    CvSVM svm;	

    if( !ok )
    {
        printf( "Could not read the database %s\n", data_filename );
        return -1;
    }

    printf( "The database %s is loaded.\n", data_filename );
    nsamples_all = data->rows;
    ntrain_samples = (int)(nsamples_all*0.9);


    // Create or load svm classifier
    if( filename_to_load )
    {
        // load classifier from the specified file
        svm.load( filename_to_load );
        ntrain_samples = 0;
		
        if( !svm.get_support_vector_count() )
        {
            printf( "Could not read the classifier %s\n", filename_to_load );
            return -1;
        }
        printf( "The classifier %s is loaded.\n", filename_to_load );
    }
    else
    {
         printf( "The classifier is in tranning...\n" );
		// 1. create type mask
		 
        var_type = cvCreateMat( data->cols, 1, CV_8U );
        cvSet( var_type, cvScalarAll(CV_VAR_CATEGORICAL) );
		//1111111111

        // 2. create sample_idx
        sample_idx = cvCreateMat( 1, nsamples_all, CV_8UC1 );
        {
            CvMat mat;
            cvGetCols( sample_idx, &mat, 0, ntrain_samples );
            cvSet( &mat, cvRealScalar(1) );

            cvGetCols( sample_idx, &mat, ntrain_samples, nsamples_all );
            cvSetZero( &mat );
        }
		//1111111000


        // 3. train classifier
        svm.train( data,responses,var_type,sample_idx,
			CvSVMParams( CvSVM::C_SVC, CvSVM::RBF ,0,0.3,0,0.1, 0, 0,
                 0, cvTermCriteria(CV_TERMCRIT_ITER,300,0.01) ));
        printf( "\n");
    }

    // compute prediction error on train and test data
    for( i = 0; i < nsamples_all; i++ )
    {
        double r;
        CvMat sample;
        cvGetRow( data, &sample, i );

        r = svm.predict( &sample );
        r = fabs((double)r - responses->data.fl[i]) <= FLT_EPSILON ? 1 : 0;

        if( i < ntrain_samples )
            train_hr += r;
        else
            test_hr += r;
    }

    test_hr /= (double)(nsamples_all-ntrain_samples);
    train_hr /= (double)ntrain_samples;
    printf( "Recognition rate: train = %.1f%%, test = %.1f%%\n",
            train_hr*100., test_hr*100. );

    printf( "Number of support_vector_count: %d\n", svm.get_support_vector_count() );

	//printf( "value of svm.get_support_vector(0): %f\n", svm.get_support_vector(0) );


    // Save classifier to file if needed
    //if( filename_to_save )
        //svm.save( filename_to_save );
	svm.save("../data/svmResult.xml");

    cvReleaseMat( &mlp_response );
    cvReleaseMat( &data );
    cvReleaseMat( &responses );

    return 0;
}



bool MachineLearning::load(const  char *training_filename)
/*************************************************
  Function:        
  Description:  训练数据载入		
  Date:			2007－3－6
  Author:   
  Input:                         
  Output:         
  Return:         
  Others:          
*************************************************/
{
	switch( traning_method )
	{
	case RandomTrees:
		forest.clear();
		build_rtrees_classifier(NULL,NULL,training_filename);
		break;
	default:
		;
	}
	is_load_training_model = true;

	return true;
}
bool MachineLearning::train(const  char *data_filename,const  char *save_filename)
/*************************************************
  Function:        
  Description:  样本数据训练		
  Date:			2007－3－6
  Author:   
  Input:                         
  Output:         
  Return:         
  Others:          
*************************************************/
{
	switch( traning_method )
	{
	case RandomTrees:
		forest.clear();
		build_rtrees_classifier(data_filename,save_filename,NULL);
		break;
	default:
		;
	}
	is_load_training_model = true;
	return true;
}
bool MachineLearning::predict(char &shape_type,float featureData[])
/*************************************************
  Function:        
  Description:  样本数据预测		
  Date:			2007－3－6
  Author:   
  Input:                         
  Output:         
  Return:         
  Others:          
*************************************************/
{
	if(is_load_training_model)
	{
		//float featureData[10];
		//getCrossFeature(img,featureData);
		
		//to do build sample
		CvMat *sample_data= cvCreateMat( 1, DataCount, CV_32F );
		//cvSet2D(sample_data,0,0,cvRealScalar(0));
		for(int i=0;i<DataCount;i++)
		{
			cvSet2D(sample_data,0,i,cvRealScalar(featureData[i]));
		}
		//float ss[23];
		//memcpy(ss,sample_data->data.fl,sizeof(float)*23); 

		switch( traning_method )
		{
		case RandomTrees:
			predict_rtrees_classifier(sample_data,shape_type);
			break;
		default:
			;
		}
		cvReleaseMat(&sample_data);

		return true;
	}
	else
		 return false;
}

int MachineLearning::predict_rtrees_classifier(CvMat *sample_data,char &shape_type)
{
	double r = forest.predict( sample_data );
	shape_type = (char)r;
	return 0;
}

trainingtools.cpp

// TrainingTools.cpp : 定义控制台应用程序的入口点。
//

//   26个字母要按一定笔划顺序书写。书写的规律有以下几点：  
//联机大写字母书写规则
//1. C J L O S U V W Z  一笔划完成 
//2. B D G K M N P Q T X Y   两笔划完成 
//3. A E F H I R      三笔划完成 

//online upper letter rule
//1. C J L O S U V W Z        finish in one stroke
//2. B D G K M N P Q T X Y    finish in two stroke
//3. A E F H I R              finish in three stroke


#include "stdafx.h"
#include "windows.h"
#include <iostream>
#include <string.h>
#include <cxcore.h>
#include <cv.h>
#include <highgui.h>
#include <fstream>
#include "Finger.h"
#include "MachineLearning.h"

#pragma comment(lib,"opencv_core2410d.lib")
#pragma comment(lib,"opencv_highgui2410d.lib")
#pragma comment(lib,"opencv_ml2410d.lib")
#pragma comment(lib,"opencv_imgproc2410.lib")

IplImage *image = 0 ; //原始图像
IplImage *image2 = 0 ; //原始图像

using namespace std;

const int SCALE_MAX = 500;
const DWORD IDLE_TIME_SPAN = 1000; //间隔一秒内没有输入，开始写入数据
const int SAMPLE_COUNT = 50; //每条曲线 五十个特征点
const int SAMPLE_COUNT_OPT = 5; //每条曲线只取五维
DWORD start_time =0;
DWORD idle_time =0;
bool InRecongnize = true;  //0 训练   1 预测
char pre_letter =0;
MachineLearning ml;

std::vector< FingerTrack > FingerTrackList;
std::vector <Finger>::iterator Itr_Finger;
std::vector< FingerTrack >::iterator Itr_FingerTrack;
std::vector< FingerTrack > FingerTrackListOpt;//优化轮廓

bool inTrack =false;
void WriteData(float featureData[]);
int DFT();
void toNormalSize();
int traing_data =0;
char letter='A';

CvFont mycvFont;

//归一化处理
void toNormalSize()
{
	int max_temp_x=0;
	int max_temp_y=0;
	int min_temp_x=10000;
	int min_temp_y=10000;
	for(int i=0;i<(int)FingerTrackListOpt.size();i++)
	{
		int ListObjSize = (int)FingerTrackListOpt[i].track.size();
		for(int j=0;j<(int)ListObjSize;j++)	
		{				
			//FingerTrackListOpt[i].track[j].center.x -=FingerTrackListOpt[i].track[0].center.x; 
			//FingerTrackListOpt[i].track[j].center.y -=FingerTrackListOpt[i].track[0].center.y;
			max_temp_x = max((FingerTrackListOpt[i].track[j].center.x),max_temp_x);
			max_temp_y = max((FingerTrackListOpt[i].track[j].center.y),max_temp_y);
			min_temp_x = min((FingerTrackListOpt[i].track[j].center.x),min_temp_x);
			min_temp_y = min((FingerTrackListOpt[i].track[j].center.y),min_temp_y);
		}		
	}


	for(int i=0;i<(int)FingerTrackListOpt.size();i++)
	{
		int ListObjSize = (int)FingerTrackListOpt[i].track.size();
		for(int j=0;j<(int)ListObjSize;j++)	
		{				
			FingerTrackListOpt[i].track[j].center.x -=min_temp_x; 
			FingerTrackListOpt[i].track[j].center.y -=min_temp_y;
		}
	}

	int MaxW = max(max_temp_x-min_temp_x,max_temp_y-min_temp_y); //最大的
	for(int i=0;i<(int)FingerTrackListOpt.size();i++)
	{
		int ListObjSize = (int)FingerTrackListOpt[i].track.size();
		for(int j=0;j<(int)ListObjSize;j++)	
		{				
			FingerTrackListOpt[i].track[j].center.x =(int)((float)FingerTrackListOpt[i].track[j].center.x/MaxW*SCALE_MAX); 
			FingerTrackListOpt[i].track[j].center.y =(int)((float)FingerTrackListOpt[i].track[j].center.y/MaxW*SCALE_MAX);   
		}
	}

}


void analysis()
{
	FingerTrackListOpt.clear();
	for(int i=0;i<(int)FingerTrackList.size();i++)
	{
		//创建FingerTrack 加入FingerTrackListOpt
		FingerTrack ft;			
		FingerTrackListOpt.push_back(ft);
		CvPoint start_pt = FingerTrackList[i].track[0].center;		
		Finger fg;
		fg.center  = start_pt;
		FingerTrackListOpt[i].track.push_back(fg);	

		//求取距离总和
		long total_dis =0;
		int ListObjSize = (int)FingerTrackList[i].track.size();
		for(int j=0;j<ListObjSize-1;j++)	
		{
			CvPoint pt = FingerTrackList[i].track[j].center;
			CvPoint pt_next = FingerTrackList[i].track[j+1].center;
			long distance = (pt_next.x - pt.x)*(pt_next.x - pt.x) +  (pt_next.y - pt.y)*(pt_next.y - pt.y);
			total_dis+=(long)sqrt((float)distance);
		}
		int search_len = total_dis/(SAMPLE_COUNT+2); //确定分割长度，取20等份
		assert(search_len>0);

		//插值
		for(int j=0;j<ListObjSize;j++)				
		{				

			CvPoint pt = FingerTrackList[i].track[j].center;
			long distance = (start_pt.x - pt.x)*(start_pt.x - pt.x) +  (start_pt.y - pt.y)*(start_pt.y - pt.y);
			distance = (long)sqrt((float)distance);
			if(distance>search_len)
			{
				//在轨迹上计算一个插值虚拟点
				float radio = (float)search_len/distance;
				start_pt.x = (int)(start_pt.x + (pt.x - start_pt.x)*radio);
				start_pt.y = (int)(start_pt.y + (pt.y - start_pt.y)*radio);
				Finger fg;
				fg.center  = start_pt;
				FingerTrackListOpt[i].track.push_back(fg);	
				j--;
			}				
		}
	}

	//归一化处理
	toNormalSize();



};
//写入特征数据到文件或者数组
void WriteData(float featureData[])
{
	std::fstream logfile("data.txt",std::ios::app);	
	int Tracksize = (int)FingerTrackListOpt.size();
	if(!InRecongnize)
	{
		logfile<<letter<<",";
		logfile<<Tracksize;
	}

	featureData[0] = (float)Tracksize;
	int f_index = 0;

	for(int i=0;i<Tracksize;i++)
	{		
		int ListObjSize = (int)FingerTrackListOpt[i].track.size();
		assert(ListObjSize>=SAMPLE_COUNT);

		float pcadata[SAMPLE_COUNT_OPT];
		int fData[SAMPLE_COUNT];	
		//X DFT
		for(int j=0;j<SAMPLE_COUNT;j++)
		{			
			fData[j] = FingerTrackListOpt[i].track[j].center.x;			
		}
		ml.ExtractDFT(pcadata,fData,SAMPLE_COUNT,SAMPLE_COUNT_OPT);
		for(int k=0;k<SAMPLE_COUNT_OPT;k++)
		{
			if(!InRecongnize) logfile<<","<<pcadata[k];
			f_index++;
			featureData[f_index] = pcadata[k];


		}
		//Y DFT
		for(int j=0;j<SAMPLE_COUNT;j++)
		{			
			fData[j] = FingerTrackListOpt[i].track[j].center.y;			
		}
		ml.ExtractDFT(pcadata,fData,SAMPLE_COUNT,SAMPLE_COUNT_OPT);
		for(int k=0;k<SAMPLE_COUNT_OPT;k++)
		{
			if(!InRecongnize) logfile<<","<<pcadata[k];
			f_index++;
			featureData[f_index] = pcadata[k];
		}


	}
	for(int i=Tracksize;i<3;i++) //用0填充
	{			
		for(int j=0;j<SAMPLE_COUNT_OPT;j++)
		{
			if(!InRecongnize) logfile<<","<<0;
			if(!InRecongnize) logfile<<","<<0;
			f_index++;
			featureData[f_index] =  0.0f; 
			f_index++;
			featureData[f_index] =  0.0f; 
		}
	}
	if(!InRecongnize) logfile<<"\n";
	logfile.close();
}

static void on_mouse( int event, int x, int y, int flags, void *param )
{
	if( event == CV_EVENT_LBUTTONDOWN )
	{
		if(!inTrack)
		{
			FingerTrack ft;			
			FingerTrackList.push_back(ft);
			inTrack = true;

		}

	} 
	else if ( event == CV_EVENT_MOUSEMOVE )
	{
		if(inTrack)
		{
			Finger fg;
			fg.center  = cvPoint(x,y);
			FingerTrackList.back().track.push_back(fg);		
			idle_time =0;
		}
	}
	else if ( event == CV_EVENT_LBUTTONUP ) 
	{
		inTrack = false;
		//analysis();

		start_time = timeGetTime();
		analysis();
		//DFT();

	}

};
void OnChangeData(int pos)
{
	letter = pos+'A';
}

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


	std::cout<<"                == The upper letter online handwriting recongnize ==" << std::endl;
	std::cout<<" 1. there two state (recongnizing and traning) for the app,In recongnizing mode,use your mouse write upper letter on 'Win' window,after 1 second,then will get result on Win2" << std::endl;
	std::cout<<" 2. you can press 'm' key to change mode from recongnizing to traning or back." << std::endl;	
	std::cout<<" 3. In traning mode,change the value of letter, then you can write upper letter on 'Win' window, and app will write data into data.txt." << std::endl;
	std::cout<<" 4. you can retrain the traning data by press 't' without restart program." << std::endl;
	std::cout<<" 5. you can modify the traning data 'data.txt' by hand if you want. " << std::endl<< std::endl;
	std::cout<<" enjoy it.:)" << std::endl<< std::endl;
	std::cout<<" ===============================================================" << std::endl;



	CvSize image_sz = cvSize( 1000,1000); 
	image = cvCreateImage(image_sz , 8, 3 );
	image2 = cvCreateImage(image_sz , 8, 3 );

	cvNamedWindow("Win",0);
	cvNamedWindow("Win2",0);
	cvSetMouseCallback( "Win", on_mouse, 0 );
	cvResizeWindow("Win",500,500);
	cvResizeWindow("Win2",500,500);
	cvCreateTrackbar("Letter", "Win2", &traing_data, 25, OnChangeData);

	mycvFont = cvFont(5,2);
	ml.DataCount = 1 + SAMPLE_COUNT_OPT*2*3;
	ml.train("data.txt",0);	


	for(;;)
	{			
		//set Timer		
		idle_time = timeGetTime()-start_time;
		if(idle_time>IDLE_TIME_SPAN && FingerTrackList.size()>0 && !inTrack)
		{

			float featureData[31];
			//记录训练数据
			WriteData(featureData);
			idle_time = 0;
			FingerTrackList.clear();
			FingerTrackListOpt.clear();

			if(InRecongnize)
			{
				pre_letter = 0;
				ml.predict(pre_letter,featureData);

			}

		}

		cvZero(image);
		cvZero(image2);

		for(int i=0;i<(int)FingerTrackList.size();i++)
		{
			for(int j=0;j<(int)FingerTrackList[i].track.size();j++)	
				cvCircle(image,FingerTrackList[i].track[j].center,10,CV_RGB(0,255,0),1,8,0);
		}

		for(int i=0;i<(int)FingerTrackListOpt.size();i++)
		{
			for(int j=0;j<(int)FingerTrackListOpt[i].track.size();j++)	
			{
				CvPoint newpt = FingerTrackListOpt[i].track[j].center;
				newpt.x =newpt.x/2+image2->width/2;
				newpt.y =newpt.y/2+image2->height/2;
				cvLine(image2,cvPoint(image2->width/2,0),cvPoint(image2->width/2 ,image2->height),CV_RGB(255,255,0),2,8,0);
				cvLine(image2,cvPoint(0,image2->height/2),cvPoint(image2->width ,image2->height/2),CV_RGB(255,255,0),2,8,0);				
				cvCircle(image2,newpt,10,CV_RGB(255,0,0),1,8,0);
			}
		}


		CvPoint pt_info;

		if(InRecongnize) 
		{
			pt_info = cvPoint(20,920);
			mycvFont = cvFont(2,2);
			cvPutText(image2,"recongnizing result = ",pt_info,&mycvFont,CV_RGB(20,250,250));
			if(pre_letter!=0)
			{
				mycvFont = cvFont(5,2);
				pt_info = cvPoint(400,920);
				cvPutText(image2,&pre_letter,pt_info,&mycvFont,CV_RGB(255,0,0));
			}
		}
		else
		{
			mycvFont = cvFont(5,2);
			pt_info = cvPoint(290,920);
			cvPutText(image2,&letter,pt_info,&mycvFont,CV_RGB(20,250,250));
			mycvFont = cvFont(2,2);
			pt_info = cvPoint(20,920);
			cvPutText(image2,"is traning...",pt_info,&mycvFont,CV_RGB(20,250,250));			

		}



		cvShowImage("Win",image);
		cvShowImage("Win2",image2);
		int keyCode = cvWaitKey(10);
		if (keyCode==27) break;
		if (keyCode=='c')
		{
			FingerTrackList.clear();
			FingerTrackListOpt.clear();
		}
		if (keyCode=='t')
		{			
			ml.train("data.txt",0);	
		}
		if (keyCode=='m')
		{
			InRecongnize = InRecongnize^1;
		}

	}

	return 0;
}


int DFT()
{
	for(int k=0;k<(int)FingerTrackListOpt.size();k++)
	{

		int ListObjSize = (int)FingerTrackListOpt[k].track.size();
		//if(ListObjSize==20) break;
		printf("\n\nListObjSize %d ",ListObjSize);

		CvMat* s = cvCreateMat(1,ListObjSize,CV_32FC1);
		CvMat* d = cvCreateMat(1,ListObjSize,CV_32FC1);
		CvMat* s2 = cvCreateMat(1,ListObjSize,CV_32FC1);

		long avg_x =0;
		long avg_y =0;
		for(int j=0;j<(int)ListObjSize;j++)	
		{
			CvPoint pt = FingerTrackListOpt[k].track[j].center;
			avg_x +=pt.x;
			avg_y +=pt.y;
		}
		avg_x = avg_x/ListObjSize;
		avg_y = avg_y/ListObjSize;

		for(int j=0;j<(int)ListObjSize;j++)	
		{
			CvPoint pt = FingerTrackListOpt[k].track[j].center;
			float dis =(float)((pt.x-avg_x)* (pt.x-avg_x) +  (pt.y-avg_y)* (pt.y-avg_y));
			dis = sqrt(dis);
			cvSetReal2D(s,0,j,dis);
		}
		//for(int j=0;j<(int)ListObjSize;j++)	
		//{
		//	printf("%6.2f ",cvGetReal2D(s,0,j));
		//}

		printf(" \n");

		//DFT 离散傅立叶变换
		cvDFT(s,d,CV_DXT_FORWARD);     //CV_DXT_FORWARD 代表了正变换：空域－〉频域

		printf("\n The result of DFT: ");
		for(int j=0;j<(int)ListObjSize;j++)	
			printf("%6.2f ",cvGetReal2D(d,0,j));

		//printf(" \n");
		////DFT 离散傅立叶逆变换
		//cvDFT(d,s2,CV_DXT_INV_SCALE); //逆变换
		//printf("\n The result of IDFT: ");
		//for(int j=0;j<(int)ListObjSize;j++)	
		//	printf("%6.2f ",cvGetReal2D(s2,0,j));
		//printf(" ");

		cvReleaseMat(&s);
		cvReleaseMat(&d);
		cvReleaseMat(&s2);
	}
	return 0;
}

实现效果：