/*! \fn CvBinGabAdaFeatureSelect::init_weights() */ void CvBinGabAdaFeatureSelect::init_weights() { weights = cvCreateMat(nsamples, 1, CV_32FC1); double posweight, negweight; posweight = 1.0/npositive/2.0; negweight = 1.0/nnegative/2.0; if( possub > 0 ) // face recogntion { for(int i = 0; i < nsamples; i++) { int id = (int)cvGetReal1D(classIdx, i); if(id == possub) cvSetReal1D(weights, i, posweight); else cvSetReal1D(weights, i, negweight); } } else //gender detection { for(int i = 0; i < nsamples; i++) { int id = (int)cvGetReal1D(classIdx, i); bool sex = ((CvXm2vts*)database)->getGender( id ); if(sex) cvSetReal1D(weights, i, posweight); else cvSetReal1D(weights, i, negweight); } } }
void mitk::UndistortCameraImage::SetUndistortImageFastInfo(float in_dF1, float in_dF2, float in_dPrincipalX, float in_dPrincipalY, float in_Dist[4], float ImageSizeX, float ImageSizeY) { //create new matrix m_DistortionCoeffs = cvCreateMat(4, 1, CV_64FC1); m_CameraMatrix = cvCreateMat(3, 3, CV_64FC1); //set the camera matrix [fx 0 cx; 0 fy cy; 0 0 1]. cvSetReal2D(m_CameraMatrix, 0, 0, in_dF1); cvSetReal2D(m_CameraMatrix, 0, 1, 0.0); cvSetReal2D(m_CameraMatrix, 0, 2, in_dPrincipalX); cvSetReal2D(m_CameraMatrix, 1, 0, 0.0); cvSetReal2D(m_CameraMatrix, 1, 1, in_dF2); cvSetReal2D(m_CameraMatrix, 1, 2, in_dPrincipalY); cvSetReal2D(m_CameraMatrix, 2, 0, 0.0); cvSetReal2D(m_CameraMatrix, 2, 1, 0.0); cvSetReal2D(m_CameraMatrix, 2, 2, 1.0); //set distortions coefficients cvSetReal1D(m_DistortionCoeffs, 0, in_Dist[0]); cvSetReal1D(m_DistortionCoeffs, 1, in_Dist[1]); cvSetReal1D(m_DistortionCoeffs, 2, in_Dist[2]); cvSetReal1D(m_DistortionCoeffs, 3, in_Dist[3]); m_mapX = cvCreateMat(ImageSizeY, ImageSizeX, CV_32FC1); m_mapY = cvCreateMat(ImageSizeY, ImageSizeX, CV_32FC1); //cv::initUndistortRectifyMap(m_CameraMatrix, m_DistortionCoeffs, m_mapX, m_mapY); cvInitUndistortMap(m_CameraMatrix, m_DistortionCoeffs, m_mapX, m_mapY); }
/*! \fn CvGaborFeature::_XM2VTSBin(const char *pathname, int possub, const CvMat *index) const */ CvTrainingData* CvGaborFeature::_XM2VTSBin(const char *pathname, int possub, const CvMat *index) const { int nopic = 4; int nosub = 200; CvSize size = cvGetSize(index); int numpos = size.width; int numneg = (nosub-1)*4; int numsample = numneg + numpos; CvTrainingData *bindata = new CvTrainingData; bindata->init(2, numsample, 1); CvMat *mat = cvCreateMat(numsample, 1, CV_32FC1); double v; int n = 0; int begin = (possub -1)*4; int end = (possub -1)*4+numpos; while(n < numsample) { int i, j; if ( n < begin ) { i = (int)(n/4) + 1; j = (int)fmod((double)n,(double)4) + 1; v = XM2VTSdata(pathname, i, j); cvSetReal1D(mat, n, v); bindata->setclsidxofsample(2, n); } else if ((n >= begin) && ( n < end)) //postive samples { i = possub; j = n - begin + 1; v = XM2VTSdata(pathname, i, (int)cvGetReal1D(index,(j-1))); cvSetReal1D(mat, n, v); bindata->setclsidxofsample(1, n); } else //negative { i = (int)((n - end)/4) + possub + 1; j = (int)fmod((double)(n-end),(double)4)+1; v = XM2VTSdata(pathname, i, j); cvSetReal1D(mat, n, v); bindata->setclsidxofsample(2, n); } n++; } bindata->setdata(mat); cvReleaseMat(&mat); bindata->statclsdist(); return bindata; }
/*! \fn CvGaborFeature::_XM2VTSBin_F(const char *pathname, int possub) const */ CvTrainingData* CvGaborFeature::_XM2VTSBin_F(const char *pathname, int possub) const { CvMat *index = cvCreateMat(1, 4, CV_32FC1); cvSetReal1D(index,0,1); cvSetReal1D(index,1,2); cvSetReal1D(index,2,3); cvSetReal1D(index,3,4); CvTrainingData *bindata = _XM2VTSBin_F(pathname, possub, index); cvReleaseMat(&index); return bindata; }
/*! \fn CvGaborFeature::_XM2VTSMulti(const char *pathname, const CvMat* picIndex, const CvMat* subIndex) const */ CvTrainingData* CvGaborFeature::_XM2VTSMulti(const char *pathname, const CvMat* picIndex, const CvMat* subIndex) const { CvSize size = cvGetSize(picIndex); int npic = size.width; size = cvGetSize(subIndex); int nosub = size.width; int nsample = nosub*npic; int n = 0; CvTrainingData *data = new CvTrainingData; data->init(nosub, nsample, 1); CvMat *mat = cvCreateMat(nsample, 1, CV_32FC1); double v; for (int i = 1; i <= nosub; i++) { for (int j = 1; j <= npic; j++) { v = XM2VTSdata( pathname, (int)cvGetReal1D(subIndex, (i-1)), (int)cvGetReal1D(picIndex, (j-1)) ); cvSetReal1D(mat, n, v); data->setclsidxofsample(i, n); n++; } } data->setdata(mat); cvReleaseMat(&mat); data->statclsdist(); return data; }
/*! \fn CvGaborFeature::_FERETBin(const CvFeret* feret, const CvPoolParams* param) const */ CvTrainingData* CvGaborFeature::_FERETBin(const CvFeret* feret, const CvPoolParams* param) const { int numsample = feret->getNum(); CvTrainingData *bindata = new CvTrainingData; bindata->init(2, numsample, 1); CvMat *mat = cvCreateMat(numsample, 1, CV_32FC1); double v; int n = 0; string mainpath = feret->getMainpath(); for (int i = 0; i < feret->getSub(); i++) { CvSubject sub = feret->getSubject(i); for (int j = 0; j < sub.getnum(); j++) { string imgname = sub.getname(j);; int id = sub.getId(); if( param->isReduced() ) v = FERETdata( mainpath.c_str(), id, imgname.c_str(), param->isReduced() ); else v = FERETdata( mainpath.c_str(), id, imgname.c_str()); cvSetReal1D( mat, n, v ); bindata->setclsidxofsample( 1, n ); std::cout << " Go : " << n<< "\r" << std::flush; n++; } } cout << endl; bindata->setdata(mat); cvReleaseMat(&mat); bindata->statclsdist(); return bindata; }
/*! \fn CvGaborFeature::_XM2VTSBin(const char *pathname, int possub) const */ CvTrainingData* CvGaborFeature::_XM2VTSBin(const char *pathname, int possub) const { int nopic = 4; int nosub = 200; int numsample = nopic*nosub; CvTrainingData *bindata = new CvTrainingData; bindata->init(2, numsample, 1); CvMat *mat = cvCreateMat(numsample, 1, CV_32FC1); double v; int n = 0; for (int i = 1; i <= nosub; i++) { for (int j = 1; j <= nopic; j++) { v = XM2VTSdata(pathname, i, j); cvSetReal1D(mat, n, v); if (i == possub) bindata->setclsidxofsample(1, n); else bindata->setclsidxofsample(2, n); std::cout << " Go : " << n<< "\r" << std::flush; n++; } } cout << endl; bindata->setdata(mat); cvReleaseMat(&mat); bindata->statclsdist(); return bindata; }
/*! \fn CvGaborFeature::_XM2VTSBin(const char *pathname) const */ CvTrainingData* CvGaborFeature::_XM2VTSBin(const char *pathname) const { int nopic = 8; int nosub = 200; int numsample = nopic*nosub; CvTrainingData *bindata = new CvTrainingData; bindata->init(2, numsample, 1); CvMat *mat = cvCreateMat(numsample, 1, CV_32FC1); double v; int n = 0; for (int i = 1; i <= nosub; i++) { for (int j = 1; j <= nopic; j++) { v = XM2VTSdata(pathname, i, j); cvSetReal1D(mat, n, v); bindata->setclsidxofsample(1, n); n++; } } bindata->setdata(mat); cvReleaseMat(&mat); bindata->statclsdist(); return bindata; }
/*! \fn CvGaborFeature::_XM2VTSGender_F(const CvXm2vts* xm2vts, int ntpic) const */ CvTrainingData* CvGaborFeature::_XM2VTSGender_F(const CvXm2vts* xm2vts, int ntpic) const { int nosub = 200; int nopic = 8; /* Generate filename */ char *filename = new char[100]; char *ch_scale = new char[5]; char *ch_orient = new char[5]; char *ch_name = new char[10]; strcpy( filename, xm2vts->getPath() ); sprintf( ch_scale, "%d", iNu ); strcat(filename, ch_scale); strcat(filename, "/"); sprintf( ch_orient, "%d", iMu ); strcat( filename, ch_orient ); strcat(filename, "/"); sprintf(ch_name, "%d_%d.xml", ix, iy); strcat(filename, ch_name); delete [] ch_scale; delete [] ch_orient; delete [] ch_name; /* Generate filename */ /* Get data from the file */ CvMat* mat = (CvMat*)cvLoad( filename, NULL, NULL, NULL ); int numsample = nosub*ntpic; CvTrainingData *bindata = new CvTrainingData; CvMat* tmpmat = cvCreateMat(numsample, 1, CV_32FC1); bindata->init(2, numsample, 1); int n = 0; double v; for(int sub = 0; sub < nosub; sub++) { int ind; bool gender = xm2vts->getGender( sub+1 ); if (gender) ind = 1; else ind = 2; for(int i = 0; i < ntpic; i++) { v = cvGetReal1D( mat, sub*nopic + i); cvSetReal1D( tmpmat, sub*ntpic+i, v); bindata->setclsidxofsample( ind, sub*ntpic+i); } } bindata->setdata(tmpmat); cvReleaseMat(&tmpmat); cvReleaseMat(&mat); delete [] filename; bindata->statclsdist(); return bindata; }
/*! \fn CvBinGabAdaFeatureSelect::setDB(CvFaceDB* db) */ void CvBinGabAdaFeatureSelect::setDB(CvFaceDB* db) { database = db->clone(); char * dbname = database->getName(); if( !strcmp(dbname, "XM2VTS")) this->db_type = XM2VTS; else if ( !strcmp(dbname, "FERET")) this->db_type = FERET; printf("...............a %s database copied!\n\n", dbname); if(db_type == XM2VTS) { nClass = ((CvXm2vts*)database)->get_num_sub(); nperClass = ((CvXm2vts*)database)->get_num_pic(); nsamples = nClass*nperClass; classIdx = cvCreateMat(nsamples, 1, CV_32SC1); int n = 0; for(int i = 0; i < nClass; i++) { for(int j = 0; j < nperClass; j++) { cvSetReal1D(classIdx, n, i+1); n++; } } } else if(db_type == FERET) { nClass = ((CvFeret*)database)->getSub(); nsamples = ((CvFeret*)database)->getNum(); classIdx = cvCreateMat(nsamples, 1, CV_32SC1); int n = 0; for(int i = 0; i < nClass; i++) { CvSubject subject = ((CvFeret*)database)->getSubject(i); int num = subject.getnum(); int id = subject.getId(); for(int j = 0; j < num; j++) { cvSetReal1D(classIdx, n, id); n++; } } } }
void MixGaussian::MakeLookUpTable() { CvMat * SampleMat = cvCreateMat(3, 1, CV_64FC1); for(int R = 0; R < 256 ; R++) { printf("."); for(int G = 0; G < 256 ; G++) { for(int B = 0; B < 256 ; B++) { cvSetReal1D(SampleMat, 0, (double)R); cvSetReal1D(SampleMat, 1, (double)G); cvSetReal1D(SampleMat, 2, (double)B); _Probability[R][G][B] = GetProbability(SampleMat); } } } cvReleaseMat(&SampleMat); }
bool MixGaussian::LoadFile(char *filename) { FILE *fp = fopen(filename, "rt"); if(!fp) return false; int nMixture = 0; fscanf(fp, "%d", &nMixture); int nDim = 0; fscanf(fp, "%d", &nDim); _nDim = nDim; CvMat *MeanMat = cvCreateMat(nDim, 1, CV_64FC1); CvMat *CovMat = cvCreateMat(nDim, nDim, CV_64FC1); cvSetZero(CovMat); float Weight = 0; for(int i = 0; i < nMixture ; i++) { float value; // Set Mean for(int j = 0; j < nDim ; j++) { fscanf(fp, "%f", &value); cvSetReal1D(MeanMat, j, value); } // Set diagonal Covariance for(int j = 0; j < nDim ; j++) { fscanf(fp, "%f", &value); cvSetReal2D(CovMat, j, j, value); } // Set Weight fscanf(fp, "%f", &value); Weight = value; // add a gaussian AddGaussian(MeanMat, CovMat, Weight); } cvReleaseMat(&MeanMat); cvReleaseMat(&CovMat); fclose(fp); return true; }
/*! \fn CvBinGabAdaFeatureSelect::svmpredict(IplImage *img, CvSVM *svm, int nfeatures) */ float CvBinGabAdaFeatureSelect::svmpredict(IplImage *img, CvSVM *svm, int nfeatures) { if( nfeatures > new_pool->getSize()) { perror("Number of features exceeds the maximal!\n"); exit(-1); } CvMat *test_sample = cvCreateMat(1, nfeatures, CV_32FC1); double vfeature; for (int i = 0; i < nfeatures; i++) { /* load feature value */ CvGaborFeature *feature; feature = new_pool->getfeature( i ); vfeature = feature->val( img ); cvSetReal1D( test_sample, i, vfeature ); } float result = svm->predict( test_sample ); //printf("The class number is %f\n", result); return result; }
int RandomTrees::train(const char* samples_filename, const char* model_filename, const double ratio, double &train_error, double &test_error) { CvMat* data = 0; CvMat* responses = 0; CvMat* var_type = 0; CvMat* sample_idx = 0; this->tree_parameters_.nactive_vars = (int)sqrt(this->number_of_features_); int ok = read_num_class_data( samples_filename, this->number_of_features_, &data, &responses ); int nsamples_all = 0, ntrain_samples = 0; int i = 0; double train_hr = 0, test_hr = 0; CvRTrees forest; CvMat* var_importance = 0; if( !ok ) { cout << "Could not read the sample in" << samples_filename << endl;; return -1; } cout << "The sample file " << samples_filename << " is loaded." << endl; nsamples_all = data->rows; ntrain_samples = (int)(nsamples_all * ratio); // create classifier by using <data> and <responses> cout << "Training the classifier ..." << endl; // 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 ); // 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 ); } // 3. train classifier forest.train( data, CV_ROW_SAMPLE, responses, 0, sample_idx, var_type, 0, this->tree_parameters_); cout << endl; // compute prediction error on train and test data for( i = 0; i < nsamples_all; i++ ) { double r; CvMat sample; cvGetRow( data, &sample, i ); r = forest.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; train_error = 1 - train_hr; test_error = 1 - test_hr; cout << "Recognition rate: train = " << train_hr*100 << ", test = " << test_hr*100 << endl; cout << "Number of trees: " << forest.get_tree_count() << endl; // Print variable importance var_importance = (CvMat*)forest.get_var_importance(); if( var_importance ) { double rt_imp_sum = cvSum( var_importance ).val[0]; printf("var#\timportance (in %%):\n"); for( i = 0; i < var_importance->cols; i++ ) printf( "%-2d\t%-4.1f\n", i,100.f*var_importance->data.fl[i]/rt_imp_sum); } // Save Random Trees classifier to file if needed if( model_filename ) forest.save( model_filename ); //cvReleaseMat( &var_importance ); //causes a segmentation fault cvReleaseMat( &sample_idx ); cvReleaseMat( &var_type ); cvReleaseMat( &data ); cvReleaseMat( &responses ); return 0; }
void cveSetReal1D(CvArr* arr, int idx0, double value) { cvSetReal1D(arr, idx0, value); }
/*! \fn CvGaborFeature::_XM2VTSBin_F(const char *pathname, int possub, const CvMat *index) const */ CvTrainingData* CvGaborFeature::_XM2VTSBin_F(const char *pathname, int possub, const CvMat *index) const { int nosub = 200; int nopic = 8; int ntpic = 4; /* Generate filename */ char *filename = new char[100]; char *ch_scale = new char[5]; char *ch_orient = new char[5]; char *ch_name = new char[10]; strcpy( filename, pathname ); sprintf( ch_scale, "%d", iNu ); strcat(filename, ch_scale); strcat(filename, "/"); sprintf( ch_orient, "%d", iMu ); strcat( filename, ch_orient ); strcat(filename, "/"); sprintf(ch_name, "%d_%d.xml", ix, iy); strcat(filename, ch_name); delete [] ch_scale; delete [] ch_orient; delete [] ch_name; /* Generate filename */ CvMat* mat = (CvMat*)cvLoad( filename, NULL, NULL, NULL ); CvSize size = cvGetSize( index ); CvSize size1 = cvGetSize( mat ); int num = size1.height; int num_example = size.height; int numneg = ( nosub - 1 )*4; int numpos = num_example - numneg; int numsample = numneg + numpos; CvTrainingData *bindata = new CvTrainingData; CvMat* tmpmat = cvCreateMat(numsample, 1, CV_32FC1); bindata->init(2, numsample, 1); int n = 0; double v; for(int sub = 0; sub < nosub; sub++) { if(sub == (possub-1)) { for(int i = 0; i < numpos; i++) { double ind = cvGetReal1D(index, i); v = cvGetReal1D(mat, sub*nopic+(int)(ind-1)); cvSetReal1D(tmpmat, sub*ntpic+i, v); bindata->setclsidxofsample( 1, sub*ntpic+i ); n++; } } else if (sub < (possub -1)) { for(int pic = 0; pic < nopic; pic++) { if(pic < 4) { v = cvGetReal1D(mat, sub*nopic+pic); cvSetReal1D(tmpmat, sub*ntpic+pic, v); bindata->setclsidxofsample( 2, sub*ntpic+pic ); } n++; } } else if (sub > (possub -1)) { for(int pic = 0; pic < nopic; pic++) { if(pic < 4) { v = cvGetReal1D(mat, sub*nopic+pic); cvSetReal1D(tmpmat, (sub-1)*ntpic+numpos+pic, v); bindata->setclsidxofsample( 2, (sub-1)*ntpic+numpos+pic ); } n++; } } } bindata->setdata(tmpmat); cvReleaseMat(&tmpmat); cvReleaseMat(&mat); delete [] filename; bindata->statclsdist(); return bindata; }
void CTWithWater::imageAndDepthToWorld(double u, double v, double d, double* x, double* y, double* z, bool undistort) { double xx, yy, t; CvMat* r = cvCreateMat(3, 1, CV_32FC1); if(undistort) { CvMat* I = cvCreateMat(1, 1, CV_32FC2); CvMat* Io = cvCreateMat(1, 1, CV_32FC2); cvSet2D(I, 0, 0, cvScalar(u,v)); cvUndistortPoints(I, Io, m_CameraMatrix, m_DistCoeffs, NULL, m_CameraMatrixNorm); CvScalar s = cvGet2D(Io, 0, 0); xx = s.val[0];//cvGetReal1D(Io, 0); yy = s.val[1];//cvGetReal1D(Io, 1); cvReleaseMat(&I); cvReleaseMat(&Io); } else { xx = u; yy = v; } xx = (xx - cvGetReal2D(m_CameraMatrixNorm, 0, 2))/cvGetReal2D(m_CameraMatrixNorm, 0, 0); yy = (yy - cvGetReal2D(m_CameraMatrixNorm, 1, 2))/cvGetReal2D(m_CameraMatrixNorm, 1, 1); cvSetReal1D(r, 0, xx); cvSetReal1D(r, 1, yy); cvSetReal1D(r, 2, 1.0); /* Rt_(3,:)*r = sum of third column of R times elements of r */ t = xx*cvGetReal2D(m_R, 0, 2) + yy*cvGetReal2D(m_R, 1, 2) + cvGetReal2D(m_R, 2, 2); if(t == 0) { t = 1.0; } if(d <= 0) { /* d<= 0 => above water surface */ t = (-m_dCameraHeightAboveWater-d)/t; /* r = t*R'*r + C */ cvGEMM(m_R, r, t, m_CameraWorld, 1.0, r, CV_GEMM_A_T); } else { /* d > 0 => below water surface */ t = -m_dCameraHeightAboveWater/t; /* S = t*R'*r */ cvGEMM(m_R, r, t, NULL, 0, m_S, CV_GEMM_A_T); double Sx = cvGetReal1D(m_S, 0); double Sy = cvGetReal1D(m_S, 1); double phi = atan2(Sy, Sx); double rS = sqrt(Sx*Sx + Sy*Sy); double rP = calculateRpFromRs(rS, d, m_dCameraHeightAboveWater); cvSetReal1D(r, 0, rP*cos(phi)); cvSetReal1D(r, 1, rP*sin(phi)); cvSetReal1D(r, 2, -m_dCameraHeightAboveWater-d); cvAdd(r, m_CameraWorld, r); } *x = cvGetReal1D(r, 0); *y = cvGetReal1D(r, 1); *z = cvGetReal1D(r, 2); cvReleaseMat(&r); }
void tips(IplImage *img) { FILE *tipgraph = fopen("tipgraph.dat","w"); //FILE *freq = fopen("freq.dat", "w"); int i, j, curr_pixel, step, x[640]; tipcount=0; uchar *data = (uchar*)img->imageData; step = img->widthStep; CvMat *dst = cvCreateMat(1, 640, CV_32FC1 ); CvMat *src = cvCreateMat(1, 640, CV_32FC1 ); for(i=0; i<width; i++) { x[i] = 0; for(j=0; j<height; j++) { curr_pixel = data[j*step + i]; if((curr_pixel == 255) ) { //data[x[i]*step + i] = 0; x[i] = j; } //else data[j*step + i] = 0; } cvSetReal1D(src, i, x[i]); fprintf(tipgraph, "%d\n", x[i]); //printf("hi"); } cvDFT(src, dst, CV_DXT_SCALE, 0); for(i=0; i<width; i++) { //fprintf(freq, "%f\n", abs(cvGetReal1D(dst, i))); if(i>20) cvSetReal1D(dst, i, 0); } cvDFT(dst, src, CV_DXT_INVERSE, 0); for(i=1; i<width-1; i++) { if((cvGetReal1D(src, i+1) - cvGetReal1D(src, i) <= 0 && cvGetReal1D(src, i) - cvGetReal1D(src, i-1) >= 0) //|| (cvGetReal1D(src, i+1) - cvGetReal1D(src, i) <= 0 && cvGetReal1D(src, i+1) - cvGetReal1D(src, i) >=-5 && cvGetReal1D(src, i) - cvGetReal1D(src, i-1) <= 0 && cvGetReal1D(src, i) - cvGetReal1D(src, i-1) >= -5) ) { tips_position[tipcount][0] = 0; for(j=-3; j<=3; j++) { if((i+j)<640 && (i+j)>0) { tips_position[tipcount][0] += x[i+j]; } } tips_position[tipcount][0] = (tips_position[tipcount][0])/7; if(tips_position[tipcount][0] > 40) { if((tipcount > 1) && (i-tips_position[tipcount-1][1]) < 55) { tips_position[tipcount-1][0] = (tips_position[tipcount-1][0] + tips_position[tipcount][0]) / 2; tips_position[tipcount-1][1] = (tips_position[tipcount-1][1] + i) / 2; } else { tips_position[tipcount++][1] = i; } } } fprintf(tipgraph, "%f\n", cvGetReal1D(src, i)); } //printf("%d\t",tipcount); fclose(tipgraph); correlated_tips(); //fclose(freq); }
/*! \fn CvBinGabAdaFeatureSelect::svmlearning(const char* path, int nofeatures, CvSVM * svm) */ void CvBinGabAdaFeatureSelect::svmlearning(const char* path, int nofeatures, CvSVM * svm) { if( db_type == XM2VTS ) { printf("Training an SVM classifier ................\n"); CvXm2vts *xm2vts = (CvXm2vts*)database; int nTrainingExample = 200*4; CvMat* trainData = cvCreateMat(nTrainingExample, nofeatures, CV_32FC1); CvMat* response = cvCreateMat(nTrainingExample, 1, CV_32FC1); for (int i = 0; i < nofeatures; i++) { /* load feature value */ CvGaborFeature *feature; feature = new_pool->getfeature(i); printf("Getting the %d feature ............\n", i+1); char *filename = new char[50]; //training validation double l, t; int fal = 0; for(int sub = 1; sub <= 200; sub++) { if (((CvXm2vts*)database)->getGender( sub )) t = 1.0; else t = 2.0; for(int pic = 1; pic <= 4; pic++) { sprintf(filename, "%s/%d_%d.bmp", path, sub, pic); IplImage *img = cvLoadImage( filename, CV_LOAD_IMAGE_ANYCOLOR ); IplImage *grayimg = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1); if ( img->nChannels == 1 ) cvCopy( img, grayimg, NULL ); else if (img->nChannels == 3) cvCvtColor( img, grayimg, CV_RGB2GRAY ); double vfeature = feature->val( img ); cvSetReal2D( trainData, ((sub-1)*4+(pic-1)), i, vfeature ); cvSetReal1D( response, ((sub-1)*4+(pic-1)), t ); cvReleaseImage(&img); cvReleaseImage(&grayimg); } } delete [] filename; } printf("building the svm classifier .........................\n"); CvTermCriteria term_crit = cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 200, 0.8); /*Type of SVM, one of the following types: CvSVM::C_SVC - n-class classification (n>=2), allows imperfect separation of classes with penalty multiplier C for outliers. CvSVM::NU_SVC - n-class classification with possible imperfect separation. Parameter nu (in the range 0..1, the larger the value, the smoother the decision boundary) is used instead of C. CvSVM::ONE_CLASS - one-class SVM. All the training data are from the same class, SVM builds a boundary that separates the class from the rest of the feature space. CvSVM::EPS_SVR - regression. The distance between feature vectors from the training set and the fitting hyperplane must be less than p. For outliers the penalty multiplier C is used. CvSVM::NU_SVR - regression; nu is used instead of p. */ int _svm_type = CvSVM::NU_SVC; /*The kernel type, one of the following types: CvSVM::LINEAR - no mapping is done, linear discrimination (or regression) is done in the original feature space. It is the fastest option. d(x,y) = x•y == (x,y) CvSVM::POLY - polynomial kernel: d(x,y) = (gamma*(x•y)+coef0)degree CvSVM::RBF - radial-basis-function kernel; a good choice in most cases: d(x,y) = exp(-gamma*|x-y|2) CvSVM::SIGMOID - sigmoid function is used as a kernel: d(x,y) = tanh(gamma*(x•y)+coef0) */ int _kernel_type = CvSVM::POLY; double _degree = 3.0; double _gamma = 1.0; double _coef0 = 0.0; double _C = 1.0; double _nu = 1.0; double _p = 1.0; CvSVMParams params( CvSVM::C_SVC, CvSVM::POLY, _degree, _gamma, _coef0, _C, _nu, _p, 0, term_crit ); svm->train( trainData, response, 0, 0, params ); svm->save( "svm.xml", "svm" ); cvReleaseMat(&response); cvReleaseMat(&trainData); } }
void OpencvRFclassifier::learn(std::vector< std::vector<float> >& pfeatures, std::vector<int>& plabels){ if (_rf){ delete _rf; _trees.clear(); _tree_weights.clear(); } _rf = new CvRTrees; int rows = pfeatures.size(); int cols = pfeatures[0].size(); printf("Number of samples and dimensions: %d, %d\n",rows, cols); if ((rows<1)||(cols<1)){ return; } // clock_t start = clock(); std::time_t start, end; std::time(&start); CvMat *features = cvCreateMat(rows, cols, CV_32F); CvMat *labels = cvCreateMat(rows, 1 , CV_32F); float* datap = features->data.fl; float* labelp = labels->data.fl; int numzeros=0; for(int i=0; i < rows; i++){ labelp[i] = plabels[i]; numzeros += ( labelp[i] == -1? 1 : 0 ); for(int j=0; j < cols ; j++){ datap[i*cols+j] = (float)pfeatures[i][j]; } } printf("Number of merge: %d\n",numzeros); // 1. create type mask CvMat* var_type = cvCreateMat( features->cols + 1, 1, CV_8U ); cvSet( var_type, cvScalarAll(CV_VAR_NUMERICAL) ); cvSetReal1D( var_type, features->cols, CV_VAR_CATEGORICAL ); // define the parameters for training the random forest (trees) float priors[] = {1,1}; // weights of each classification for classes // (all equal as equal samples of each digit) CvRTParams params = CvRTParams( _max_depth, // max depth :the depth of the tree 10, // min sample count: minimum samples required at a leaf node for it to be split 0, // regression accuracy: N/A here false, // compute surrogate split, no missing data 15, // max number of categories (use sub-optimal algorithm for larger numbers) priors, // the array of prior for each class false, // calculate variable importance 5, // number of variables randomly selected at node and used to find the best split(s). _tree_count, // max number of trees in the forest 0.001f, // forest accuracy CV_TERMCRIT_ITER //| CV_TERMCRIT_EPS // termination cirteria ); // 3. train classifier _rf->train( features, CV_ROW_SAMPLE, labels, 0, 0, var_type, 0, params); //CvRTParams(10,10,0,false,15,0,true,4,100,0.01f,CV_TERMCRIT_ITER)); float correct = 0; for(int i = 0; i < features->rows ; i++ ){ float r; CvMat sample; cvGetRow( features, &sample, i ); r = _rf->predict_prob( &sample ); r = (r>0.5)? 1 :-1; r = fabs((float)r - labels->data.fl[i]) <= FLT_EPSILON ? 1 : 0; correct += r; } std::time(&end); printf("Time required to learn RF: %.2f sec\n", (difftime(end,start))*1.0); // printf("Time required to learn RF: %.2f sec\n", ((float)clock() - start) / CLOCKS_PER_SEC); printf("with training set accuracy :%.3f\n", correct/features->rows*100.); _tree_count = _rf->get_tree_count(); for(int i = 0; i < _tree_count; i++){ CvForestTree* treep = _rf->get_tree(i); _trees.push_back(treep); } //int ntrees = _rf->get_tree_count(); _tree_weights.resize(_tree_count, 1.0/_tree_count); cvReleaseMat( &features ); cvReleaseMat( &labels ); cvReleaseMat( &var_type ); }
static int build_boost_classifier( char* data_filename, char* filename_to_save, char* filename_to_load ) { const int class_count = 26; 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, 16, &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.5); 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)...\n"); 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; }
void CTWithWater::worldToImage(double x, double y, double z, double* u, double* v, bool distort) { double d = m_dWaterDepth - z; /* d > 0 => point is below surface of water */ if(d > 0) { double phi = atan2(y - cvGetReal1D(m_CameraWorld, 1), x - cvGetReal1D(m_CameraWorld, 0)); double rP = sqrt((x-cvGetReal1D(m_CameraWorld, 0)) *(x-cvGetReal1D(m_CameraWorld, 0)) + (y-cvGetReal1D(m_CameraWorld, 1)) *(y-cvGetReal1D(m_CameraWorld, 1))); double rS = solveRsFromRp(rP, d, m_dCameraHeightAboveWater); cvSetReal1D(m_S, 0, rS*cos(phi)); cvSetReal1D(m_S, 1, rS*sin(phi)); cvSetReal1D(m_S, 2, -m_dCameraHeightAboveWater); /* S = CW + S */ cvAdd(m_S, m_CameraWorld, m_S); } else { /* point is above water surface and can be used directly */ cvSetReal1D(m_S, 0, x); cvSetReal1D(m_S, 1, y); cvSetReal1D(m_S, 2, z); } /* S = R*S + T */ cvGEMM(m_R, m_S, 1.0, m_T, 1.0, m_S); /* in camera coordinats */ x = cvGetReal1D(m_S, 0); y = cvGetReal1D(m_S, 1); z = cvGetReal1D(m_S, 2); if(z == 0) { z = 1.0; } x = x/z; y = y/z; if(distort) { double xx, yy, r2, k1, k2, k3, p1, p2; r2 = (x*x + y*y); k1 = cvGetReal1D(m_DistCoeffs, 0); k2 = cvGetReal1D(m_DistCoeffs, 1); p1 = cvGetReal1D(m_DistCoeffs, 2); p2 = cvGetReal1D(m_DistCoeffs, 3); k3 = cvGetReal1D(m_DistCoeffs, 4); xx = x*(1 + k1*r2 + k2*r2*r2 + k3*r2*r2*r2) + 2.0*p1*x*y + p2*(r2 + 2.0*x*x); yy = y*(1 + k1*r2 + k2*r2*r2 + k3*r2*r2*r2) + p1*(r2 + 2.0*y*y) + 2.0*p2*x*y; *u = cvGetReal2D(m_CameraMatrix, 0, 0)*x + cvGetReal2D(m_CameraMatrix, 0, 2); *v = cvGetReal2D(m_CameraMatrix, 1, 1)*y + cvGetReal2D(m_CameraMatrix, 1, 2); } else { *u = cvGetReal2D(m_CameraMatrixNorm, 0, 0)*x + cvGetReal2D(m_CameraMatrixNorm, 0, 2); *v = cvGetReal2D(m_CameraMatrixNorm, 1, 1)*y + cvGetReal2D(m_CameraMatrixNorm, 1, 2); } }
/*! \fn CvGaborFeature::_XM2VTSMulti_F(const char *pathname, const CvMat* picIndex, const CvMat* subIndex) const */ CvTrainingData* CvGaborFeature::_XM2VTSMulti_F(const char *pathname, const CvMat* picIndex, const CvMat* subIndex) const { int nosub = 200; int nopic = 8; /* Generate filename */ char *filename = new char[100]; char *ch_scale = new char[5]; char *ch_orient = new char[5]; char *ch_name = new char[10]; strcpy( filename, pathname ); sprintf( ch_scale, "%d", iNu ); strcat(filename, ch_scale); strcat(filename, "/"); sprintf( ch_orient, "%d", iMu ); strcat( filename, ch_orient ); strcat(filename, "/"); sprintf(ch_name, "%d_%d.xml", ix, iy); strcat(filename, ch_name); delete [] ch_scale; delete [] ch_orient; delete [] ch_name; /* Generate filename */ CvMat* mat = (CvMat*)cvLoad( filename, NULL, NULL, NULL ); //printf("Open %s \n", filename); //assert( mat ); if(!CV_IS_MAT( mat )) { //retry 10 times for(int i = 0; i < 10; i++) { time_t rawtime; struct tm * timeinfo; time ( &rawtime ); timeinfo = localtime ( &rawtime ); perror( asctime (timeinfo) ); perror("Can not get a matrix from "); perror(filename); sleep( 10 ); // sleep for 10 sec mat = (CvMat*)cvLoad( filename, NULL, NULL, NULL ); if (CV_IS_MAT( mat )) break; } } CvSize size = cvGetSize( picIndex ); CvSize size1 = cvGetSize( mat ); CvSize size2 = cvGetSize(subIndex); int num = size1.height; int ntpic = size.width; int ntsub = size2.width; int numsample = ntsub*ntpic; CvTrainingData *bindata = new CvTrainingData; CvMat* tmpmat = cvCreateMat(numsample, 1, CV_32FC1); bindata->init(ntsub, numsample, 1); int n = 0; int m = 0; double v; for(int sub = 1; sub <= nosub; sub++) { for(int pic = 1; pic <= nopic; pic++) { for(int j = 0; j < ntsub; j++) { for(int i = 0; i < ntpic; i++) { if((pic == cvGetReal1D(picIndex, i))&&(sub == cvGetReal1D(subIndex, j))) { v = cvGetReal1D(mat, n); cvSetReal1D(tmpmat, m, v); bindata->setclsidxofsample(sub, m); m++; } } } n++; } } bindata->setdata(tmpmat); cvReleaseMat(&tmpmat); cvReleaseMat(&mat); delete [] filename; bindata->statclsdist(); return bindata; }
int main(int argc, char **argv) { IplImage *inputImg; trainImage sample; cvNamedWindow("With COM", CV_WINDOW_AUTOSIZE); // CvCapture* capture = 0; // capture = cvCreateCameraCapture(-1); // if(!capture){ // return -1; // } // inputImg = cvQueryFrame(capture); #include <opencv2/ml/ml.hpp> float result; initializeFaceProcessor(); CvMat* SampleMatrix; CvMat* PjMatrix=(CvMat*)cvLoad("/home/umut/projects/fastTrainer/build/ProjectionMatrix.xml"); int newDimension=PjMatrix->cols; // int newDimension; CvMat* allFeatures; CvMat* LDAMatrix=cvCreateMat(newDimension,1,CV_32F); // CvBoost booster; // // booster.load("/home/umut/projects/fastTrainer/build/Booster.dat"); int trans=CV_GEMM_A_T; CvSVM SVM; SVM.load("/home/umut/projects/fastTrainer/build/SVM_CLASS.dat"); // Grab the next frame from the camera. // while((inputImg = cvQueryFrame(capture)) != NULL ){ for (int i=1;i<argc;i++){ inputImg=cvLoadImage(argv[i]); if(processFace(inputImg, sample.FaceImage, sample.MouthImage, sample.NoseImage, sample.EyeImage, 0)) { sample.LBPHF=LBP_HF(sample.FaceImage,sample.nonUniform,sample.complete); //Pass through the LBPHF // sample.EyeImage=filterGabor(sample.EyeImage); // sample.NoseImage=filterGabor(sample.NoseImage); // sample.MouthImage=filterGabor(sample.MouthImage); mat2Col(&sample,0,1,0,SampleMatrix); // newDimension=SampleMatrix->rows; allFeatures=cvCreateMat(1,35+2+newDimension,CV_32F); cvGEMM(PjMatrix,SampleMatrix,1,NULL,0,LDAMatrix,trans); cvSetReal1D(allFeatures,0,sample.complete); cvSetReal1D(allFeatures,1,sample.nonUniform); for (int j=0;j<35;j++) cvSetReal1D(allFeatures,2+j,sample.LBPHF[j]); for (int j=0;j <newDimension;j++) // cvSetReal1D(allFeatures,37+j,cvGetReal1D(SampleMatrix,j)); cvSetReal1D(allFeatures,37+j,cvGetReal1D(LDAMatrix,j)); // cout<< "feature Size: "<< allFeatures->cols << "\n"; // result=booster.predict(allFeatures,0,booster.get_weak_response()); result=SVM.predict(allFeatures); if (result==0) { cvRectangle(sample.FaceImage,cvPoint(2,2),cvPoint(sample.FaceImage->width-2,sample.FaceImage->height-2),cvScalar(255,0,0),3); printf("Result is male\n"); } else { cvRectangle(sample.FaceImage,cvPoint(2,2),cvPoint(sample.FaceImage->width-2,sample.FaceImage->height-2),cvScalar(0,0,255),3); printf("Result is female\n"); } cvShowImage("With COM",sample.FaceImage); char c=cvWaitKey(0); // char c=cvWaitKey(5); // if (c==27) break; } } if (strcmp(argv[1],"1")) cvReleaseImage( &inputImg); }
/*! \fn CvGaborFeature::_XM2VTSMulti_F(const char *pathname, const CvMat* index) const */ CvTrainingData* CvGaborFeature::_XM2VTSMulti_F(const char *pathname, const CvMat* index) const { int nosub = 200; int nopic = 8; /* Generate filename */ char *filename = new char[100]; char *ch_scale = new char[5]; char *ch_orient = new char[5]; char *ch_name = new char[10]; strcpy( filename, pathname ); sprintf( ch_scale, "%d", iNu ); strcat(filename, ch_scale); strcat(filename, "/"); sprintf( ch_orient, "%d", iMu ); strcat( filename, ch_orient ); strcat(filename, "/"); sprintf(ch_name, "%d_%d.xml", ix, iy); strcat(filename, ch_name); delete [] ch_scale; delete [] ch_orient; delete [] ch_name; /* Generate filename */ CvMat* mat = (CvMat*)cvLoad( filename, NULL, NULL, NULL ); CvSize size = cvGetSize( index ); CvSize size1 = cvGetSize( mat ); int num = size1.height; int ntpic = size.width; int numsample = nosub*ntpic; CvTrainingData *bindata = new CvTrainingData; CvMat* tmpmat = cvCreateMat(numsample, 1, CV_32FC1); bindata->init(nosub, numsample, 1); int n = 0; int m = 0; double v; for(int sub = 1; sub <= nosub; sub++) { for(int pic = 1; pic <= nopic; pic++) { for(int i = 0; i < ntpic; i++) { if(pic == cvGetReal1D(index, i)) { v = cvGetReal1D(mat, n); cvSetReal1D(tmpmat, m, v); bindata->setclsidxofsample(sub, m); m++; } } n++; } } bindata->setdata(tmpmat); cvReleaseMat(&tmpmat); cvReleaseMat(&mat); delete [] filename; bindata->statclsdist(); return bindata; }
void calibrateViews(std::vector<CvPoint2D32f>& corners, int rows, int cols) { int nViews = corners.size()/(rows*cols); LINFO("Calibrate: %i views", nViews); if (nViews <= 0) { LINFO("No corners avl"); return; } // Set up the object points matrix // Squares are size set in defines found in header file. CvMat* object_points = cvCreateMat(corners.size(), 3, CV_32FC1); for(uint k=0; k < corners.size()/(rows*cols); k++ ) { for(int i=0; i < cols; i++ ) { for(int j=0; j < rows; j++ ) { cvmSet( object_points, k*(rows*cols) + i*rows + j, 0, GRID_SIZE*j ); // x coordinate cvmSet( object_points, k*(rows*cols) + i*rows + j, 1, GRID_SIZE*i ); // y coordinate cvmSet( object_points, k*(rows*cols) + i*rows + j, 2, 0 ); // z coordinate } } } //for (uint j = 0; j < corners.size(); j++){ // cvSetReal2D( object_points, j, 0, ( j % rows) * GRID_SIZE ); // cvSetReal2D( object_points, j, 1, ( j / rows) * GRID_SIZE ); // cvSetReal2D( object_points, j, 2, 0.0 ); //} // Set up the matrix of points per image CvMat* point_counts = cvCreateMat(1, nViews, CV_32SC1); for(int i=0; i < nViews; i++ ) cvSetReal1D( point_counts, i, rows*cols ); // Copy corners found to matrix CvMat image_points = cvMat(corners.size(), 2, CV_32FC1, &corners[0]); int flags = 0; // Initiliazie the intrinsic matrix such that the two focal lengths // have a ratio of 1.0 cvmSet( itsIntrinsicMatrix, 0, 0, 1.0); cvmSet( itsIntrinsicMatrix, 1, 1, 1.0); //flags = CV_CALIB_FIX_PRINCIPAL_POINT; // | CV_CALIB_USE_INTRINSIC_GUESS; //flags = CV_CALIB_USE_INTRINSIC_GUESS; flags = CV_CALIB_FIX_ASPECT_RATIO; cvCalibrateCamera2( object_points, &image_points, point_counts, cvSize(320,240), itsIntrinsicMatrix, itsDistortionCoeffs, NULL, NULL, flags); //display results // Image<byte> in = itsPCameraCellsInput[0]; // Image<byte> out(in.getDims(), ZEROS); // cvUndistort2( img2ipl(in), img2ipl(out), itsIntrinsicMatrix, itsDistortionCoeffs); // //itsDebugImg = out; cvReleaseMat( &object_points); cvReleaseMat( &point_counts); }
int AdaBoost::train(const char* samples_filename, const char* model_filename, const double ratio, double &train_error, double &test_error) { CvMat* data = 0; CvMat* responses = 0; CvMat* var_type = 0; CvMat* temp_sample = 0; CvMat* weak_responses = 0; int ok = read_num_class_data( samples_filename, this->number_of_features_, &data, &responses ); int nsamples_all = 0, ntrain_samples = 0; int var_count = 0; int i=0, j=0, k=0; double train_hr = 0, test_hr = 0; CvBoost boost; if( !ok ) { cout << "Could not read the sample in" << samples_filename << endl;; return -1; } cout << "The sample file " << samples_filename << " is loaded." << endl; nsamples_all = data->rows; ntrain_samples = (int)(nsamples_all * ratio); var_count = data->cols; // create classifier by using <data> and <responses> cout << "Training the classifier ..." << endl; // create classifiers CvMat* new_data = cvCreateMat(ntrain_samples * this->number_of_classes_, var_count + 1 , CV_32F );//+1 CvMat* new_responses = cvCreateMat( ntrain_samples * this->number_of_classes_, 1, CV_32S ); // unroll the database type mask printf( "Unrolling the samples ...\n"); for( i = 0; i < ntrain_samples; i++ ) { float* data_row = (float*)(data->data.ptr + data->step*i); for( j = 0; j < this->number_of_classes_; j++ ) { float* new_data_row = (float*)(new_data->data.ptr + new_data->step*(i * this->number_of_classes_ + 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 * this->number_of_classes_ + j] = responses->data.fl[i] == j + FIRST_LABEL; } } // 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 );//CV_VAR_CATEGORICAL CV_VAR_NUMERICAL cvSetReal1D( var_type, var_count+1, CV_VAR_CATEGORICAL ); //CV_VAR_CATEGORICAL // 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, this->boost_parameters_); 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 < this->number_of_classes_; 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 + FIRST_LABEL; } } r = fabs(best_class - responses->data.fl[i]) < FLT_EPSILON ? 1 : 0; if( i < ntrain_samples ) train_hr += r; else test_hr += r; } train_hr /= (double)ntrain_samples; test_hr /= ((double)nsamples_all - (double)ntrain_samples); cout << "Recognition rate: train = " << train_hr * 100 << ", test = " << test_hr * 100 << endl; // fill result-parameters train_error = 1 - train_hr; test_error = 1 - test_hr; // Save classifier to file if needed if( model_filename ) boost.save( model_filename ); boost.clear(); cvReleaseMat( &temp_sample ); cvReleaseMat( &weak_responses ); cvReleaseMat( &var_type ); cvReleaseMat( &data ); cvReleaseMat( &responses ); return 0; }
static int build_rtrees_classifier( char* data_filename, char* filename_to_save, char* filename_to_load ) { CvMat* data = 0; CvMat* responses = 0; CvMat* var_type = 0; CvMat* sample_idx = 0; int ok = read_num_class_data( data_filename, 16, &data, &responses ); int nsamples_all = 0, ntrain_samples = 0; int i = 0; double train_hr = 0, test_hr = 0; CvRTrees forest; 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); // Create or load Random Trees classifier if( filename_to_load ) { // load classifier from the specified file forest.load( filename_to_load ); ntrain_samples = 0; 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 { // create classifier by using <data> and <responses> printf( "Training the classifier ...\n"); // 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 ); // 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 ); } // 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 for( i = 0; i < nsamples_all; i++ ) { double r; CvMat sample; cvGetRow( data, &sample, i ); r = forest.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 trees: %d\n", forest.get_tree_count() ); // Print variable importance var_importance = (CvMat*)forest.get_var_importance(); if( var_importance ) { double rt_imp_sum = cvSum( var_importance ).val[0]; printf("var#\timportance (in %%):\n"); for( i = 0; i < var_importance->cols; i++ ) printf( "%-2d\t%-4.1f\n", i, 100.f*var_importance->data.fl[i]/rt_imp_sum); } //Print some proximitites printf( "Proximities between some samples corresponding to the letter 'T':\n" ); { CvMat sample1, sample2; const int pairs[][2] = {{0,103}, {0,106}, {106,103}, {-1,-1}}; for( i = 0; pairs[i][0] >= 0; i++ ) { cvGetRow( data, &sample1, pairs[i][0] ); cvGetRow( data, &sample2, pairs[i][1] ); printf( "proximity(%d,%d) = %.1f%%\n", pairs[i][0], pairs[i][1], forest.get_proximity( &sample1, &sample2 )*100. ); } } // Save Random Trees classifier to file if needed if( filename_to_save ) forest.save( filename_to_save ); cvReleaseMat( &sample_idx ); cvReleaseMat( &var_type ); cvReleaseMat( &data ); cvReleaseMat( &responses ); return 0; }
void CV_QueryHistTest::run_func(void) { int i, iters = values->cols; CvArr* h = hist[0]->bins; const int* idx = indices->data.i; float* val = values->data.fl; float default_value = 0.f; // stage 1: write bins if( cdims == 1 ) for( i = 0; i < iters; i++ ) { float v0 = values0->data.fl[i]; if( fabs(v0 - default_value) < FLT_EPSILON ) continue; if( !(i % 2) ) { if( !(i % 4) ) cvSetReal1D( h, idx[i], v0 ); else *(float*)cvPtr1D( h, idx[i] ) = v0; } else cvSetRealND( h, idx+i, v0 ); } else if( cdims == 2 ) for( i = 0; i < iters; i++ ) { float v0 = values0->data.fl[i]; if( fabs(v0 - default_value) < FLT_EPSILON ) continue; if( !(i % 2) ) { if( !(i % 4) ) cvSetReal2D( h, idx[i*2], idx[i*2+1], v0 ); else *(float*)cvPtr2D( h, idx[i*2], idx[i*2+1] ) = v0; } else cvSetRealND( h, idx+i*2, v0 ); } else if( cdims == 3 ) for( i = 0; i < iters; i++ ) { float v0 = values0->data.fl[i]; if( fabs(v0 - default_value) < FLT_EPSILON ) continue; if( !(i % 2) ) { if( !(i % 4) ) cvSetReal3D( h, idx[i*3], idx[i*3+1], idx[i*3+2], v0 ); else *(float*)cvPtr3D( h, idx[i*3], idx[i*3+1], idx[i*3+2] ) = v0; } else cvSetRealND( h, idx+i*3, v0 ); } else for( i = 0; i < iters; i++ ) { float v0 = values0->data.fl[i]; if( fabs(v0 - default_value) < FLT_EPSILON ) continue; if( !(i % 2) ) cvSetRealND( h, idx+i*cdims, v0 ); else *(float*)cvPtrND( h, idx+i*cdims ) = v0; } // stage 2: read bins if( cdims == 1 ) for( i = 0; i < iters; i++ ) { if( !(i % 2) ) val[i] = *(float*)cvPtr1D( h, idx[i] ); else val[i] = (float)cvGetReal1D( h, idx[i] ); } else if( cdims == 2 ) for( i = 0; i < iters; i++ ) { if( !(i % 2) ) val[i] = *(float*)cvPtr2D( h, idx[i*2], idx[i*2+1] ); else val[i] = (float)cvGetReal2D( h, idx[i*2], idx[i*2+1] ); } else if( cdims == 3 ) for( i = 0; i < iters; i++ ) { if( !(i % 2) ) val[i] = *(float*)cvPtr3D( h, idx[i*3], idx[i*3+1], idx[i*3+2] ); else val[i] = (float)cvGetReal3D( h, idx[i*3], idx[i*3+1], idx[i*3+2] ); } else for( i = 0; i < iters; i++ ) { if( !(i % 2) ) val[i] = *(float*)cvPtrND( h, idx+i*cdims ); else val[i] = (float)cvGetRealND( h, idx+i*cdims ); } }