Exemple #1
0
//加载保存过的训练结果
int loadTrainingData(CvMat ** pTrainPersonNumMat)
{
	CvFileStorage * fileStorage;
	int i;

	
	fileStorage = cvOpenFileStorage( "facedata.xml", 0, CV_STORAGE_READ );
	if( !fileStorage )
	{
		fprintf(stderr, "Can't open facedata.xml\n");
		return 0;
	}

	nEigens = cvReadIntByName(fileStorage, 0, "nEigens", 0);
	nTrainFaces = cvReadIntByName(fileStorage, 0, "nTrainFaces", 0);
	*pTrainPersonNumMat = (CvMat *)cvReadByName(fileStorage, 0, "trainPersonNumMat", 0);
	eigenValMat  = (CvMat *)cvReadByName(fileStorage, 0, "eigenValMat", 0);
	projectedTrainFaceMat = (CvMat *)cvReadByName(fileStorage, 0, "projectedTrainFaceMat", 0);
	pAvgTrainImg = (IplImage *)cvReadByName(fileStorage, 0, "avgTrainImg", 0);
	eigenVectArr = (IplImage **)cvAlloc(nTrainFaces*sizeof(IplImage *));
	for(i=0; i<nEigens; i++)
	{
		char varname[200];
		sprintf( varname, "eigenVect_%d", i );
		eigenVectArr[i] = (IplImage *)cvReadByName(fileStorage, 0, varname, 0);
	}

	
	cvReleaseFileStorage( &fileStorage );

	return 1;
}
//////////////////////////////////
// loadTrainingData()
//
int EigenFace::loadTrainingData()
{
  LOGD("load from %s", mTrainingDataFile);
	CvFileStorage * fileStorage;
	int i;
  
	// create a file-storage interface
	fileStorage = cvOpenFileStorage( mTrainingDataFile, 0, CV_STORAGE_READ );
	if( !fileStorage )
	{
		LOGE("Can't open facedata.xml\n");
		return 0;
	}
  
	nEigens = cvReadIntByName(fileStorage, 0, "nEigens", 0);
	nTrainFaces = cvReadIntByName(fileStorage, 0, "nTrainFaces", 0);
	trainPersonNumMat = (CvMat *)cvReadByName(fileStorage, 0, "trainPersonNumMat", 0);
	eigenValMat  = (CvMat *)cvReadByName(fileStorage, 0, "eigenValMat", 0);
	projectedTrainFaceMat = (CvMat *)cvReadByName(fileStorage, 0, "projectedTrainFaceMat", 0);
	pAvgTrainImg = (IplImage *)cvReadByName(fileStorage, 0, "avgTrainImg", 0);
	eigenVectArr = (IplImage **)cvAlloc(nTrainFaces*sizeof(IplImage *));
	for(i=0; i<nEigens; i++)
	{
		char varname[200];
		sprintf( varname, "eigenVect_%d", i );
		eigenVectArr[i] = (IplImage *)cvReadByName(fileStorage, 0, varname, 0);
	}
  
	// release the file-storage interface
	cvReleaseFileStorage( &fileStorage );
  
	return 1;
}
Exemple #3
0
void ReadFeature(
		char* fileName,
		FEATURE* feature){
	CvFileStorage* fs = cvOpenFileStorage( fileName, 0, CV_STORAGE_READ, NULL);
	if (fs==NULL){
		fprintf(stderr, "can't open feature file!\n");
		return;
	}
	feature->radius 	= cvReadIntByName(fs, NULL, "radius", RADIUS);
	feature->neighbors	= cvReadIntByName(fs, NULL, "neighbors", NEIGHBORS);
	feature->grid_x		= cvReadIntByName(fs, NULL, "grid_x", GRID_X);
	feature->grid_y		= cvReadIntByName(fs, NULL, "grid_y", GRID_Y);
	feature->num_faces	= cvReadIntByName(fs, NULL, "num_faces", 0);

	char faceid[1024];
	char id[20];
	feature->histogram = (CvMat**) malloc(feature->num_faces*sizeof(CvMat*));
	for (int i=0; i<feature->num_faces; i++){
		strcpy(faceid, "face-");
		sprintf(id, "%d", i);
		strcat(faceid, id);
		feature->histogram[i] = cvReadByName(fs, NULL, faceid, NULL);
	}
	if (HUELBP_ON){
		feature->hue_histogram = (CvMat**) malloc(feature->num_faces*sizeof(CvMat*));
		for (int i=0; i<feature->num_faces; i++){
			strcpy(faceid, "hue-face-");
			sprintf(id, "%d", i);
			strcat(faceid, id);
			feature->hue_histogram[i] = cvReadByName(fs, NULL, faceid, NULL);
		}
	}
	cvReleaseFileStorage( &fs );

}
// Open the training data from the file 'facedata.xml'.
int loadTrainingData(CvMat ** pTrainPersonNumMat)
{
    CvFileStorage * fileStorage;
    int i;
    
    // create a file-storage interface
    fileStorage = cvOpenFileStorage( facedata, 0, CV_STORAGE_READ );
    if( !fileStorage ) {
        printf("Can't open training database file 'facedata.xml'.\n");
        return 0;
    }
    
    // Load the person names. Added by Shervin.
    personNames.clear();	// Make sure it starts as empty.
    nPersons = cvReadIntByName( fileStorage, 0, "nPersons", 0 );
    if (nPersons == 0) {
        printf("No people found in the training database 'facedata.xml'.\n");
        return 0;
    }
    // Load each person's name.
    for (i=0; i<nPersons; i++) {
        string sPersonName;
        char varname[200];
        sprintf( varname, "personName_%d", (i+1) );
        sPersonName = cvReadStringByName(fileStorage, 0, varname );
        personNames.push_back( sPersonName );
    }
    
    // Load the data
    nEigens = cvReadIntByName(fileStorage, 0, "nEigens", 0);
    nTrainFaces = cvReadIntByName(fileStorage, 0, "nTrainFaces", 0);
    *pTrainPersonNumMat = (CvMat *)cvReadByName(fileStorage, 0, "trainPersonNumMat", 0);
    eigenValMat  = (CvMat *)cvReadByName(fileStorage, 0, "eigenValMat", 0);
    projectedTrainFaceMat = (CvMat *)cvReadByName(fileStorage, 0, "projectedTrainFaceMat", 0);
    pAvgTrainImg = (IplImage *)cvReadByName(fileStorage, 0, "avgTrainImg", 0);
    eigenVectArr = (IplImage **)cvAlloc(nTrainFaces*sizeof(IplImage *));
    for(i=0; i<nEigens; i++)
    {
        char varname[200];
        sprintf( varname, "eigenVect_%d", i );
        eigenVectArr[i] = (IplImage *)cvReadByName(fileStorage, 0, varname, 0);
    }
    
    // release the file-storage interface
    cvReleaseFileStorage( &fileStorage );
    
    printf("Training data loaded (%d training images of %d people):\n", nTrainFaces, nPersons);
    printf("People: ");
    if (nPersons > 0)
        printf("<%s>", personNames[0].c_str());
    for (i=1; i<nPersons; i++) {
        printf(", <%s>", personNames[i].c_str());
    }
    printf(".\n");
    
    return 1;
}
Exemple #5
0
void loadremap(CvMat* l_remap0, CvMat* l_remap1, CvMat* r_remap0, CvMat* r_remap1)
{
    /* 
     * Load remap information from saved remap.yml file,
     * which is generated by stereo calibration function from c++.
     * Because write a pure C-based one is too f*****g stupid.
     */
    CvFileStorage *fs = cvOpenFileStorage("remap.yml", 0, CV_STORAGE_READ, NULL);
    l_remap0 = cvReadByName(fs, NULL, "left_remap0", NULL);
    l_remap1 = cvReadByName(fs, NULL, "left_remap1", NULL);
    r_remap0 = cvReadByName(fs, NULL, "right_remap0", NULL);
    r_remap1 = cvReadByName(fs, NULL, "right_remap1", NULL);
    if (l_remap0 == NULL || l_remap1 == NULL || r_remap0 == NULL || r_remap1 == NULL) {
        printf("what the f**k dude why is this happenening I hate my life.\n");
    }
}
Exemple #6
0
int main (int argc, char *argv[]) 
{
	IplImage *img;
	CvFileStorage *fs;
	CvSeq* seq;
	CvMemStorage *str;
	int N,i;
	
	parse_args(argc,argv);

	str = cvCreateMemStorage(0);
	img = cvCreateImage(cvSize(WIDTH,HEIGHT), 8, 3);
	cvZero(img);
	fs = cvOpenFileStorage(infile, str, CV_STORAGE_READ, NULL);
	assert(fs);

	N = cvReadIntByName(fs, NULL, "N", 0);
	seq = cvReadByName(fs, NULL, "seq", 0);

	printf("N=%d\n", N);
	for (i=0; i<seq->total; i++) {
		CvPoint p;

		p = *(CvPoint*)cvGetSeqElem(seq, i);
		cvCircle(img, p, R, CV_RGB(255,0,0), -1, 8, 0);
	}

	cvShowImage("proto", img);
	cvWaitKey(0);
	
	cvReleaseFileStorage(&fs);
	cvReleaseImage(&img);
	
	return 0;
}
int main(int argc, const char * argv[]) {
    CvMat *cmatrix = cvCreateMat(5,5,CV_32FC1);
    float element_3_2 = 7.7;
    *((float*)CV_MAT_ELEM_PTR( *cmatrix, 3,2) ) = element_3_2;
    cvmSet(cmatrix,4,4,0.5000);
    cvSetReal2D(cmatrix,3,3,0.5000);
    
    CvFileStorage* fs1 = cvOpenFileStorage("cfg.xml", 0, CV_STORAGE_WRITE);
    cvWriteInt( fs1, "frame_count", 10 );
    cvStartWriteStruct( fs1, "frame_size", CV_NODE_SEQ );
    cvWriteInt( fs1 , 0, 320 );
    cvWriteInt( fs1 , 0, 200 );
    cvEndWriteStruct( fs1 );
    cvWrite( fs1, "color_cvt_matrix", cmatrix );
    cvReleaseFileStorage( &fs1 );
    
    CvFileStorage* fs2 = cvOpenFileStorage("cfg.xml", 0, CV_STORAGE_READ);
    int frame_count = cvReadIntByName( fs2 , 0, "frame_count");
    CvSeq* s = cvGetFileNodeByName( fs2,0,"frame_size" )->data.seq;
    int frame_width = cvReadInt( (CvFileNode*)cvGetSeqElem(s,0) );
    int frame_height = cvReadInt( (CvFileNode*)cvGetSeqElem(s,1) );
    CvMat* color_cvt_matrix = (CvMat*) cvReadByName( fs2, 0 , "color_cvt_matrix");
    
    printf("color_cvt_matrix: width=%d, height=%d\n",color_cvt_matrix->width, color_cvt_matrix->height );
    printf("frame_count=%d, frame_width=%d, frame_height=%d\n",frame_count,frame_width,frame_height);
    
    cvReleaseFileStorage( &fs2 );
    
    return 0;
}
bool CameraParameters::loadParameters(const char* filename){

    CvFileStorage* fstorage = 0;
    fstorage =  cvOpenFileStorage(filename, NULL,  CV_STORAGE_READ);

    if(!fstorage)
        return false;

    this->m_mat_camera_matrix = cvCloneMat( (CvMat*) cvReadByName(fstorage, 0, CAMERA_MATRIX_TAG));
    this->m_mat_distortion_coeff = cvCloneMat((CvMat*) cvReadByName(fstorage, 0, DISTORTION_COEF_TAG));

    cvReleaseFileStorage(&fstorage);

    return true;

}
Exemple #9
0
CvMat * icvReadSVHNLabels(char * filename, const int max_samples)
{
  CvFileStorage * fs = cvOpenFileStorage(filename,0,CV_STORAGE_READ);
  if (!fs){fprintf(stderr,"file loading error: %s\n",filename);return 0;}
  CvFileNode * fnode = cvGetRootFileNode(fs);
  char tagname[20]; int ii;
  const int nparams = 4;
  CvMat * data = cvCreateMat(max_samples,1+nparams*10,CV_32S); cvZero(data);
  for (ii=0;;ii++){
    sprintf(tagname,"img%d",ii+1);
    CvMat * sample = (CvMat*)cvReadByName(fs,fnode,tagname);
    if (!sample || ii==max_samples){break;}
    int nnumbers = sample->rows;
    CV_MAT_ELEM(*data,int,ii,0)=nnumbers;
    for (int jj=0;jj<nnumbers;jj++){
      float xx = CV_MAT_ELEM(*sample,float,jj,0);
      float yy = CV_MAT_ELEM(*sample,float,jj,1);
      float ww = CV_MAT_ELEM(*sample,float,jj,2);
      float hh = CV_MAT_ELEM(*sample,float,jj,3);
      float ll = CV_MAT_ELEM(*sample,float,jj,4);
      CV_MAT_ELEM(*data,int,ii,1+nparams*jj+0)=cvRound(xx+ww*.5f);  // x
      CV_MAT_ELEM(*data,int,ii,1+nparams*jj+1)=cvRound(yy+hh*.5f);  // y
      CV_MAT_ELEM(*data,int,ii,1+nparams*jj+2)=cvRound(MAX(ww,hh));   // scale
      CV_MAT_ELEM(*data,int,ii,1+nparams*jj+3)=cvRound(ll);           // label
    }
    cvReleaseMat(&sample);
  }
  data->rows = ii;
  cvReleaseFileStorage(&fs);
  return data;
}
Exemple #10
0
bool CvMatrix::read( CvFileStorage* fs, const char* mapname, const char* matname )
{
    void* obj = 0;
    CvMat* m = 0;

    if( mapname )
    {
        CvFileNode* mapnode = cvGetFileNodeByName( fs, 0, mapname );
        if( !mapnode )
            obj = cvReadByName( fs, mapnode, matname );
    }
    else
        obj = cvReadByName( fs, 0, matname );

    m = icvRetrieveMatrix(obj);
    set( m, false );
    return m != 0;
}
Exemple #11
0
bool CvImage::read( CvFileStorage* fs, const char* mapname, const char* imgname )
{
    void* obj = 0;
    IplImage* img = 0;

    if( mapname )
    {
        CvFileNode* mapnode = cvGetFileNodeByName( fs, 0, mapname );
        if( !mapnode )
            obj = cvReadByName( fs, mapnode, imgname );
    }
    else
        obj = cvReadByName( fs, 0, imgname );

    img = icvRetrieveImage(obj);
    attach( img );
    return img != 0;
}
Exemple #12
0
void CvGBTrees::read_params( CvFileStorage* fs, CvFileNode* fnode )
{
    CV_FUNCNAME( "CvGBTrees::read_params" );
    __BEGIN__;


    CvFileNode* temp;

    if( !fnode || !CV_NODE_IS_MAP(fnode->tag) )
        return;

    data = new CvDTreeTrainData();
    CV_CALL( data->read_params(fs, fnode));
    data->shared = true;

    params.max_depth = data->params.max_depth;
    params.min_sample_count = data->params.min_sample_count;
    params.max_categories = data->params.max_categories;
    params.priors = data->params.priors;
    params.regression_accuracy = data->params.regression_accuracy;
    params.use_surrogates = data->params.use_surrogates;

    temp = cvGetFileNodeByName( fs, fnode, "loss_function" );
    if( !temp )
        EXIT;

    if( temp && CV_NODE_IS_STRING(temp->tag) )
    {
        const char* loss_function_type_str = cvReadString( temp, "" );
        params.loss_function_type = strcmp( loss_function_type_str, "SquaredLoss" ) == 0 ? SQUARED_LOSS :
                            strcmp( loss_function_type_str, "AbsoluteLoss" ) == 0 ? ABSOLUTE_LOSS :
                            strcmp( loss_function_type_str, "HuberLoss" ) == 0 ? HUBER_LOSS :
                            strcmp( loss_function_type_str, "DevianceLoss" ) == 0 ? DEVIANCE_LOSS : -1;
    }
    else
        params.loss_function_type = cvReadInt( temp, -1 );


    if( params.loss_function_type < SQUARED_LOSS || params.loss_function_type > DEVIANCE_LOSS ||  params.loss_function_type == 2)
        CV_ERROR( CV_StsBadArg, "Unknown loss function" );

    params.weak_count = cvReadIntByName( fs, fnode, "ensemble_length" );
    params.shrinkage = (float)cvReadRealByName( fs, fnode, "shrinkage", 0.1 );
    params.subsample_portion = (float)cvReadRealByName( fs, fnode, "subsample_portion", 1.0 );

    if (data->is_classifier)
    {
        class_labels = (CvMat*)cvReadByName( fs, fnode, "class_labels" );
        if( class_labels && !CV_IS_MAT(class_labels))
            CV_ERROR( CV_StsParseError, "class_labels must stored as a matrix");
    }
    data->is_classifier = 0;

    __END__;
}
Exemple #13
0
void CvANN_MLP::read( CvFileStorage* fs, CvFileNode* node )
{
    CvMat* _layer_sizes = 0;
    
    CV_FUNCNAME( "CvANN_MLP::read" );

    __BEGIN__;

    CvFileNode* w;
    CvSeqReader reader;
    int i, l_count;

    _layer_sizes = (CvMat*)cvReadByName( fs, node, "layer_sizes" );
    CV_CALL( create( _layer_sizes, SIGMOID_SYM, 0, 0 ));
    l_count = layer_sizes->cols;

    CV_CALL( read_params( fs, node ));

    w = cvGetFileNodeByName( fs, node, "input_scale" );
    if( !w || CV_NODE_TYPE(w->tag) != CV_NODE_SEQ ||
        w->data.seq->total != layer_sizes->data.i[0]*2 )
        CV_ERROR( CV_StsParseError, "input_scale tag is not found or is invalid" );

    CV_CALL( cvReadRawData( fs, w, weights[0], "d" ));

    w = cvGetFileNodeByName( fs, node, "output_scale" );
    if( !w || CV_NODE_TYPE(w->tag) != CV_NODE_SEQ ||
        w->data.seq->total != layer_sizes->data.i[l_count-1]*2 )
        CV_ERROR( CV_StsParseError, "output_scale tag is not found or is invalid" );

    CV_CALL( cvReadRawData( fs, w, weights[l_count], "d" ));

    w = cvGetFileNodeByName( fs, node, "inv_output_scale" );
    if( !w || CV_NODE_TYPE(w->tag) != CV_NODE_SEQ ||
        w->data.seq->total != layer_sizes->data.i[l_count-1]*2 )
        CV_ERROR( CV_StsParseError, "inv_output_scale tag is not found or is invalid" );

    CV_CALL( cvReadRawData( fs, w, weights[l_count+1], "d" ));

    w = cvGetFileNodeByName( fs, node, "weights" );
    if( !w || CV_NODE_TYPE(w->tag) != CV_NODE_SEQ ||
        w->data.seq->total != l_count - 1 )
        CV_ERROR( CV_StsParseError, "weights tag is not found or is invalid" );

    cvStartReadSeq( w->data.seq, &reader );

    for( i = 1; i < l_count; i++ )
    {
        w = (CvFileNode*)reader.ptr;
        CV_CALL( cvReadRawData( fs, w, weights[i], "d" ));
        CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
    }

    __END__;
}
Exemple #14
0
int Eigenfaces::loadConfig(const string& dir)
{
    d->configFile = dir + string("/libface-config.xml");

    if (DEBUG)
        cout << "Load training data" << endl;

    CvFileStorage* fileStorage = cvOpenFileStorage(d->configFile.data(), 0, CV_STORAGE_READ);
    cout << "opened" << endl;
    if (!fileStorage)
    {
        if (DEBUG)
            cout << "Can't open config file for reading :" << d->configFile << endl;
        return 1;
    }

    //d->clearTrainingStructures();

    int nIds       = cvReadIntByName(fileStorage, 0, "nIds", 0), i;
    d->FACE_WIDTH  = cvReadIntByName(fileStorage, 0, "FACE_WIDTH",d->FACE_WIDTH);
    d->FACE_HEIGHT = cvReadIntByName(fileStorage, 0, "FACE_HEIGHT",d->FACE_HEIGHT);
    d->THRESHOLD   = cvReadRealByName(fileStorage, 0, "THRESHOLD", d->THRESHOLD);
    //LibFaceUtils::printMatrix(d->projectedTrainFaceMat);

    for ( i = 0; i < nIds; i++ )
    {
        char facename[200];
        sprintf(facename, "person_%d", i);
        d->faceImgArr.push_back( (IplImage*)cvReadByName(fileStorage, 0, facename, 0) );
    }

    for ( i = 0; i < nIds; i++ )
    {
        char idname[200];
        sprintf(idname, "id_%d", i);
        d->indexMap.push_back( cvReadIntByName(fileStorage, 0, idname, 0));
    }

    // Release file storage
    cvReleaseFileStorage(&fileStorage);

    return 0;
}
Exemple #15
0
int CvOneWayDescriptor::ReadByName(CvFileStorage* fs, CvFileNode* parent, const char* name)
{
	CvMat* mat = (CvMat*)cvReadByName(fs, parent, name);
	if(!mat)
	{
		return 0;
	}


	for(int i = 0; i < m_pose_count; i++)
	{
		for(int y = 0; y < m_samples[i]->height; y++)
		{
			for(int x = 0; x < m_samples[i]->width; x++)
			{
				float val = cvmGet(mat, i, y*m_samples[i]->width + x);
				*((float*)(m_samples[i]->imageData + y*m_samples[i]->widthStep) + x) = val;
			}
		}
	}

	cvReleaseMat(&mat);
	return 1;
}
void CalTarget::load(CvFileStorage *in, CvFileNode *node) {
	point.load(in, cvGetFileNodeByName(in, node, "point"));
	image.reset((cv::Mat*) cvReadByName(in, node, "image"));
	origImage.reset((cv::Mat*) cvReadByName(in, node, "origImage"));
}
Exemple #17
0
 void * cvReadByName_wrap(CvFileStorage * fs , const CvFileNode * map , const char * name , CvAttrList * attributes ){
	return cvReadByName(/*CvFileStorage*//***/fs , /*const*//*CvFileNode*//***/map , /*const*//*char*//***/name , /*CvAttrList*//***/attributes);
}
Exemple #18
0
LKInverseComp::LKInverseComp(char *path)
{
    CvFileStorage *fs;

    fs = cvOpenFileStorage(path, 0, CV_STORAGE_READ );
    nA = (int)cvReadRealByName(fs, 0, "numberOfAppearanceEigenVectors", 0);
    nS = (int)cvReadRealByName(fs, 0, "numberOfShapeEigenVectors", 0);
printf("%d %d \n",nS,nA);

//nS=16;
//
//nA=2;
//nS=4;/
nA=10;
nA+=1;








    negNewParam = (float *)malloc(sizeof(float)*(nS+4));
    negNewParamnS = (float *)malloc(sizeof(float)*(nS+4));
    negNewParam4 = (float *)malloc(sizeof(float)*(nS+4));
    ParamnS = (float *)malloc(sizeof(float)*(nS+4));
    Param4 = (float *)malloc(sizeof(float)*(nS+4));
    ptemp1 = (float *)malloc(sizeof(float)*(nS+4));
    ptemp2 = (float *)malloc(sizeof(float)*(nS+4));
    param = (float *) malloc((4+nS)*sizeof(float));
    nonRigidShapeVectors=(IplImage**)cvAlloc(sizeof(IplImage*) * nS);
    appearanceVectors=(IplImage**)cvAlloc(sizeof(IplImage*) * nA);
    globalShapeVectors=(IplImage**)cvAlloc(sizeof(IplImage*) * 4);
    combineshapevectors=(IplImage**)cvAlloc(sizeof(IplImage*) * (4+nS));
    srcShape =cvCreateImage(cvSize(totalnumberofpoints,1),IPL_DEPTH_64F,1);

    destShape =cvCreateImage(cvSize(totalnumberofpoints,1),IPL_DEPTH_64F,1);
    destShapeTemp =cvCreateImage(cvSize(totalnumberofpoints,1),IPL_DEPTH_64F,1);
    destShapewithoutQ =cvCreateImage(cvSize(totalnumberofpoints,1),IPL_DEPTH_64F,1);


    for (int m=0;m<(nS+4);m++)
    {
        combineshapevectors[m]=cvCreateImage(cvSize(totalnumberofpoints,1),IPL_DEPTH_64F,1);
        param[m]=0;

        negNewParam[m]=0;
        negNewParamnS[m]=0;
        negNewParam4[m]=0;
        ParamnS[m]=0;
        Param4[m]=0;
        ptemp1[m]=0;
        ptemp2[m]=0;
    }
    for (int m=0;m<4;m++)
        globalShapeVectors[m]=cvCreateImage(cvSize(totalnumberofpoints,1),IPL_DEPTH_64F,1);


    CvMat * meanShapeDel=cvCreateMat(numberofpoints,2,CV_64FC1);
eigenVal=   (CvMat *)cvReadByName( fs,0,"eigenVal",0 );

    // minProjVal=(IplImage *)cvReadByName( fs,0,"minProjVal",0 );
    // maxProjVal=(IplImage *)cvReadByName( fs,0,"maxProjVal",0 );

    meanAppearance=(IplImage *)cvReadByName( fs,0,"avgApp",0 );
    ErrorImage = cvCreateMat((meanAppearance->width*meanAppearance->height),1, CV_64FC1);

    IplImage* meanShapeTemp=(IplImage *)cvReadByName( fs,0,"avgShape",0 );
    meanShape=cvCreateImage(cvSize(meanShapeTemp->width,meanShapeTemp->height),IPL_DEPTH_64F,1);

    cvConvertScale( meanShapeTemp,meanShape,1,0);
    for (int m=0;m<nS;m++)
    {
        char temp[200];
        sprintf(temp,"shapeEigenVectors%d",m);
        nonRigidShapeVectors[m]=(IplImage *)cvReadByName( fs,0,temp,0 );
    }

    for (int m=0;m<nA-1;m++)
    {
        char temp[200];
        sprintf(temp,"appEigenVectors%d",m);
        appearanceVectors[m]=(IplImage *)cvReadByName( fs,0,temp,0 );
    }
        appearanceVectors[nA-1]=cvCreateImage(cvSize(appearanceVectors[nA-2]->width,appearanceVectors[nA-2]->height),IPL_DEPTH_32F,1);


for(int i=0;i<(appearanceVectors[nA-2]->width);i++)
{
    for(int j=0;j<appearanceVectors[nA-2]->height;j++)
    {
     CvScalar s;
     s.val[0]=1;
     cvSet2D(appearanceVectors[nA-1],j,i,s);
    }
}

//   IplImage * newImage = cvCreateImage(cvSize(meanAppearance->width,meanAppearance->height),IPL_DEPTH_8U,1);
    for (int m=0;m<nA;m++)
    {
        //   cvZero(newImage);

        for (int i=0;i<meanAppearance->width;i++)
        {
            for (int j=0;j<meanAppearance->height;j++)
            {

                CvScalar s= cvGet2D(appearanceVectors[m],j,i);
                s.val[0]*=255;
                CvScalar s1= cvGet2D(meanAppearance,j,i);

                s.val[0]+=s1.val[0];

                ////printf("%e \n",s.val[0]);
                //   cvSet2D(newImage,j,i,s);
            }
        }
            //         cvNamedWindow("yoyo",1);
           //cvShowImage("yoyo",newImage);

        //   cvWaitKey(-1);
    }


    for (int m=0;m<numberofpoints;m++)
    {
        CvScalar s1,s2;
        s1=cvGet2D(meanShape,0,2*m);
        s2=cvGet2D(meanShape,0,2*m+1);
        cvSet2D(meanShapeDel,m,0,s1);
        cvSet2D(meanShapeDel,m,1,s2);

        cvSet2D(globalShapeVectors[0],0,2*m,s1);
        cvSet2D(globalShapeVectors[0],0,2*m+1,s2);

        cvSet2D(combineshapevectors[0],0,2*m,s1);
        cvSet2D(combineshapevectors[0],0,2*m+1,s2);


        s2.val[0]*=-1;
        cvSet2D(globalShapeVectors[1],0,2*m,s2);
        cvSet2D(globalShapeVectors[1],0,2*m+1,s1);

        cvSet2D(combineshapevectors[1],0,2*m,s2);
        cvSet2D(combineshapevectors[1],0,2*m+1,s1);

        CvScalar one,zero;
        one.val[0]=1;
        zero.val[0]=0;
        cvSet2D(globalShapeVectors[2],0,2*m,one);
        cvSet2D(globalShapeVectors[2],0,2*m+1,zero);
        cvSet2D(globalShapeVectors[3],0,2*m,zero);
        cvSet2D(globalShapeVectors[3],0,2*m+1,one);
        cvSet2D(combineshapevectors[2],0,2*m,one);
        cvSet2D(combineshapevectors[2],0,2*m+1,zero);
        cvSet2D(combineshapevectors[3],0,2*m,zero);
        cvSet2D(combineshapevectors[3],0,2*m+1,one);
    }


    for (int i=0;i<numberofpoints;i++)
    {
        CvScalar avx,avy;


        avx=cvGet2D(  meanShapeDel, i,0);
        avy=cvGet2D(  meanShapeDel, i,1);

        // ////printf("%e %e \n",avx.val[0],avy.val[0]);

    }

    newDelaunayShapeCompute= new delaunay(meanShapeDel);
    newDelaunay = new delaunay(meanShapeDel);
    newDelaunayInverse = new delaunay(meanShapeDel);
    for (int m=0;m<4;m++)
    {

        double val=   cvNorm(globalShapeVectors[m],NULL , CV_L2, 0 );
        cvConvertScale( globalShapeVectors[m],globalShapeVectors[m],1/val,0);

        ////printf(" %e \n",val);
        //  cvConvertScale( combineshapevectors[m],combineshapevectors[m],val,0);

    }

    for (int m=4;m<(nS+4);m++)
    {


        for (int j=0;j<totalnumberofpoints;j++)
        {
            CvScalar s1 = cvGet2D(nonRigidShapeVectors[m-4],0,j);
            cvSet2D(combineshapevectors[m],0,j,s1);
        }

    }
    for (int m=0;m<nS+4;m++)
    {

        double val=   cvNorm(combineshapevectors[m],NULL , CV_L2, 0 );
        cvConvertScale( combineshapevectors[m],combineshapevectors[m],1/val,0);
        ////printf(" %e \n",val);

        //  cvConvertScale( combineshapevectors[m],combineshapevectors[m],val,0);

    }

    for (int m=0;m<nA;m++)
    {

        double val=   cvNorm(appearanceVectors[m],NULL , CV_L2, 0 );
        cvConvertScale( appearanceVectors[m],appearanceVectors[m],1/val,0);

//        //printf(" %e \n",val);

    }
    ////printf("%d %d \n",meanAppearance->width,meanAppearance->height);
    totalNumberOfPixels=newDelaunay->numberOfPixels();
    interpolateMean=(float*)malloc(sizeof(float)*totalNumberOfPixels);
    for (int i=0;i<totalNumberOfPixels;i++)
    {
        interpolateMean[i]=0;
        pixel * pix = newDelaunay->getpixel(i);
        interpolateMean[i]=interpolate<float>(meanAppearance,double(pix->x+pix->tx),double(pix->y+pix->ty));


    }

    preCompute();
    ////printf("%d %d \n",meanAppearance->width,meanAppearance->height);
//   preCompute();

}