/** * Write out a Protocol to YAML file, given an initialized CvFileStorage */ void WriteProtocol(Protocol* myP, CvFileStorage* fs){ if (fs==0){ printf("fs is zero! Could you have specified the wrong directory?\n"); return; } /** Write out Protocol **/ cvStartWriteStruct(fs,"Protocol",CV_NODE_MAP,NULL); if (myP->Filename!=NULL) cvWriteString(fs,"Filename",myP->Filename); if (myP->Description!=NULL) cvWriteString(fs,"Description",myP->Description); cvStartWriteStruct(fs,"GridSize",CV_NODE_MAP,NULL); cvWriteInt(fs,"height",myP->GridSize.height); cvWriteInt(fs,"width",myP->GridSize.width); cvEndWriteStruct(fs); //printf("yo\n"); /** Write Out Steps **/ cvStartWriteStruct(fs,"Steps",CV_NODE_SEQ,NULL); int j; int jtot=myP->Steps->total; CvSeqReader StepReader; cvStartReadSeq(myP->Steps,&StepReader,0); for (j = 0; j < jtot; ++j) { //printf("About to write step number %d\n",j); CvSeq** CurrentMontagePtr = (CvSeq**) StepReader.ptr; CvSeq* CurrentMontage=*CurrentMontagePtr; assert(CurrentMontage!=NULL); // printf("ping\n"); // printf("CurrentMontage->total=%d",CurrentMontage->total); cvStartWriteStruct(fs,NULL,CV_NODE_SEQ,NULL); int k; int ktot=CurrentMontage->total; // printf("ktot=%d\n",ktot); CvSeqReader MontageReader; cvStartReadSeq(CurrentMontage,&MontageReader); for (k = 0; k < ktot; ++k) { // printf("About to write polygon number %d\n",k); WormPolygon** CurrentPolygonPtr= (WormPolygon**) MontageReader.ptr; WormPolygon* CurrentPolygon=*CurrentPolygonPtr; cvWrite(fs,NULL,CurrentPolygon->Points); CV_NEXT_SEQ_ELEM(CurrentMontage->elem_size,MontageReader); } CurrentMontagePtr=NULL; CurrentMontage=NULL; cvEndWriteStruct(fs); /** Loop to Next Step **/ CV_NEXT_SEQ_ELEM(myP->Steps->elem_size,StepReader); } cvEndWriteStruct(fs); cvEndWriteStruct(fs); }
int CvArrTest::write_default_params( CvFileStorage* fs ) { int code = CvTest::write_default_params( fs ); if( code < 0 ) return code; if( ts->get_testing_mode() == CvTS::CORRECTNESS_CHECK_MODE ) { write_param( fs, "test_case_count", test_case_count ); write_param( fs, "min_log_array_size", min_log_array_size ); write_param( fs, "max_log_array_size", max_log_array_size ); } else if( ts->get_testing_mode() == CvTS::TIMING_MODE ) { int i; start_write_param( fs ); // make sure we have written the entry header containing the test name if( size_list ) { cvStartWriteStruct( fs, "size", CV_NODE_SEQ+CV_NODE_FLOW ); for( i = 0; size_list[i].width >= 0; i++ ) { cvStartWriteStruct( fs, 0, CV_NODE_SEQ+CV_NODE_FLOW ); cvWriteInt( fs, 0, size_list[i].width ); cvWriteInt( fs, 0, size_list[i].height ); if( whole_size_list && (whole_size_list[i].width > size_list[i].width || whole_size_list[i].height > size_list[i].height) ) { cvWriteInt( fs, 0, whole_size_list[i].width ); cvWriteInt( fs, 0, whole_size_list[i].height ); } cvEndWriteStruct( fs ); } cvEndWriteStruct(fs); } if( depth_list ) { cvStartWriteStruct( fs, "depth", CV_NODE_SEQ+CV_NODE_FLOW ); for( i = 0; depth_list[i] >= 0; i++ ) cvWriteString( fs, 0, cvTsGetTypeName(depth_list[i]) ); cvEndWriteStruct(fs); } write_int_list( fs, "channels", cn_list, -1, -1 ); if( optional_mask ) { static const int use_mask[] = { 0, 1 }; write_int_list( fs, "use_mask", use_mask, 2 ); } } return 0; }
void CvANN_MLP::write_params( CvFileStorage* fs ) { //CV_FUNCNAME( "CvANN_MLP::write_params" ); __BEGIN__; const char* activ_func_name = activ_func == IDENTITY ? "IDENTITY" : activ_func == SIGMOID_SYM ? "SIGMOID_SYM" : activ_func == GAUSSIAN ? "GAUSSIAN" : 0; if( activ_func_name ) cvWriteString( fs, "activation_function", activ_func_name ); else cvWriteInt( fs, "activation_function", activ_func ); if( activ_func != IDENTITY ) { cvWriteReal( fs, "f_param1", f_param1 ); cvWriteReal( fs, "f_param2", f_param2 ); } cvWriteReal( fs, "min_val", min_val ); cvWriteReal( fs, "max_val", max_val ); cvWriteReal( fs, "min_val1", min_val1 ); cvWriteReal( fs, "max_val1", max_val1 ); cvStartWriteStruct( fs, "training_params", CV_NODE_MAP ); if( params.train_method == CvANN_MLP_TrainParams::BACKPROP ) { cvWriteString( fs, "train_method", "BACKPROP" ); cvWriteReal( fs, "dw_scale", params.bp_dw_scale ); cvWriteReal( fs, "moment_scale", params.bp_moment_scale ); } else if( params.train_method == CvANN_MLP_TrainParams::RPROP ) { cvWriteString( fs, "train_method", "RPROP" ); cvWriteReal( fs, "dw0", params.rp_dw0 ); cvWriteReal( fs, "dw_plus", params.rp_dw_plus ); cvWriteReal( fs, "dw_minus", params.rp_dw_minus ); cvWriteReal( fs, "dw_min", params.rp_dw_min ); cvWriteReal( fs, "dw_max", params.rp_dw_max ); } cvStartWriteStruct( fs, "term_criteria", CV_NODE_MAP + CV_NODE_FLOW ); if( params.term_crit.type & CV_TERMCRIT_EPS ) cvWriteReal( fs, "epsilon", params.term_crit.epsilon ); if( params.term_crit.type & CV_TERMCRIT_ITER ) cvWriteInt( fs, "iterations", params.term_crit.max_iter ); cvEndWriteStruct( fs ); cvEndWriteStruct( fs ); __END__; }
void CalTarget::save(CvFileStorage *out, const char *name) { cvStartWriteStruct(out, name, CV_NODE_MAP); point.save(out, "point"); cvWrite(out, "image", image.get()); cvWrite(out, "origImage", origImage.get()); cvEndWriteStruct(out); }
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; }
/* * Write out to YAML the default grid size for non-protocol based illumination */ void WriteOutDefaultGridSize(WriteOut* DataWriter, WormAnalysisParam* Param){ /** Write out default grid size for non-protocol illumination **/ cvStartWriteStruct(DataWriter->fs,"DefaultGridSizeForNonProtocolIllum",CV_NODE_MAP,NULL); cvWriteInt(DataWriter->fs,"x",Param->DefaultGridSize.width); cvWriteInt(DataWriter->fs,"y",Param->DefaultGridSize.height); cvEndWriteStruct(DataWriter->fs); return; }
void write_my_struct( CvFileStorage* fs, const char* name, my_struct* ms) { cvWriteComment (fs, name, 0); cvWriteInt(fs, "integer", ms->i); cvStartWriteStruct(fs, "point", CV_NODE_SEQ); cvWriteInt(fs, 0, ms->point.x); cvWriteInt(fs, 0, ms->point.y); cvEndWriteStruct(fs); cvStartWriteStruct(fs, "rectangle", CV_NODE_SEQ); cvWriteInt(fs, 0, ms->rect.x); cvWriteInt(fs, 0, ms->rect.y); cvWriteInt(fs, 0, ms->rect.width); cvWriteInt(fs, 0, ms->rect.height); cvEndWriteStruct(fs); }
void CvGBTrees::write( CvFileStorage* fs, const char* name ) const { CV_FUNCNAME( "CvGBTrees::write" ); __BEGIN__; CvSeqReader reader; int i; cv::String s; cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_GBT ); if( !weak ) CV_ERROR( CV_StsBadArg, "The model has not been trained yet" ); write_params( fs ); cvWriteReal( fs, "base_value", base_value); cvWriteInt( fs, "class_count", class_count); for ( int j=0; j < class_count; ++j ) { s = cv::format("trees_%d", j); cvStartWriteStruct( fs, s.c_str(), CV_NODE_SEQ ); cvStartReadSeq( weak[j], &reader ); for( i = 0; i < weak[j]->total; i++ ) { CvDTree* tree; CV_READ_SEQ_ELEM( tree, reader ); cvStartWriteStruct( fs, 0, CV_NODE_MAP ); tree->write( fs ); cvEndWriteStruct( fs ); } cvEndWriteStruct( fs ); } cvEndWriteStruct( fs ); __END__; }
void save_pseudocolor(char* file, Pseudocolor *psdata) { CvFileStorage* storage = cvOpenFileStorage( file, 0, CV_STORAGE_WRITE_TEXT ); if(storage==NULL){ fprintf(stderr, "Error open file %s to write \n",file); return; } cvStartWriteStruct(storage, "p", CV_NODE_SEQ, NULL, cvAttrList(0,0)); cvWriteRawData(storage, psdata->p,3,"f"); cvEndWriteStruct(storage); cvStartWriteStruct(storage, "t", CV_NODE_SEQ, NULL, cvAttrList(0,0)); cvWriteRawData(storage, psdata->t,3,"f"); cvEndWriteStruct(storage); cvStartWriteStruct(storage, "table", CV_NODE_SEQ, NULL, cvAttrList(0,0)); cvWriteRawData(storage, psdata->table,255,"u"); cvEndWriteStruct(storage); cvReleaseFileStorage( &storage ); }
bool ObjectDefinition::Save(const char* filename) { do{ CvFileStorage* storage = cvOpenFileStorage(filename, 0, CV_STORAGE_WRITE); cvWrite(storage, "keypoints", m_keypoints); cvWrite(storage, "descriptor", m_descriptor); cvStartWriteStruct(storage, "corners", CV_NODE_SEQ, NULL, cvAttrList(0,0)); cvWriteRawData(storage, m_corners, 4, "ii"); cvEndWriteStruct(storage); cvReleaseFileStorage(&storage); m_filename = filename; return true; }while(false); return false; }
/*! \fn CvBinGabAdaFeatureSelect::saveweaks(const char *filename) */ void CvBinGabAdaFeatureSelect::saveweaks(const char *filename) { CvMemStorage* storage = cvCreateMemStorage(0); CvSeq* seq = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvGaborTree), storage ); int num = weaks.size(); for(int i = 0; i < num; i++ ) { CvGaborFeature *feature; feature = new_pool->getfeature(i); CvGaborTree tree; tree.x = feature->getx(); tree.y = feature->gety(); tree.Mu = feature->getMu(); tree.Nu = feature->getNu(); tree.alpha = alphas[i]; tree.threshold = weaks[i].getthreshold(); tree.parity = weaks[i].getparity(); cvSeqPush( seq, &tree ); } char *weakname = new char[20]; CvMemStorage* xstorage = cvCreateMemStorage( 0 ); CvFileStorage *fs = cvOpenFileStorage( filename, xstorage, CV_STORAGE_WRITE ); for (int i = 0; i <seq->total; i++) { CvGaborTree *atree = (CvGaborTree*)cvGetSeqElem(seq, i); sprintf(weakname, "weak_%d", i); cvStartWriteStruct( fs, weakname, CV_NODE_MAP, "CvGaborTree", cvAttrList(0,0) ); cvWriteInt(fs, "x", atree->x); cvWriteInt(fs, "y", atree->y); cvWriteInt(fs, "Mu", atree->Mu); cvWriteInt(fs, "Nu", atree->Nu); cvWriteReal(fs, "alpha", atree->alpha); cvWriteReal(fs, "threshold", atree->threshold); cvWriteReal(fs, "parity", atree->parity); cvEndWriteStruct( fs ); } /* release memory storage in the end */ delete [] weakname; cvReleaseMemStorage( &xstorage ); cvReleaseMemStorage( &storage ); cvReleaseFileStorage(&fs); }
int main(int argc, 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); printf("Example 3_17, writing cfg.xml\n"); CvFileStorage* fs = cvOpenFileStorage("cfg.xml", 0, CV_STORAGE_WRITE); cvWriteInt(fs, "frame_count", 10); cvStartWriteStruct(fs, "frame_size", CV_NODE_SEQ); cvWriteInt(fs, 0, 320); cvWriteInt(fs, 0, 200); cvEndWriteStruct(fs); cvWrite(fs, "color_cvt_matrix", cmatrix); cvReleaseFileStorage(&fs); return 0; }
void save_posture_model (CvFileStorage *fs, CvMat *mean, CvMat *cov) { static int i=0; static char asd[]="posture-00"; cvStartWriteStruct(fs, asd, CV_NODE_MAP, NULL, cvAttrList(0,0)); cvWriteInt(fs, "type", i++); cvWrite(fs, "mean", (void*)mean, cvAttrList(0,0)); cvWrite(fs, "cov", (void*)cov, cvAttrList(0,0)); cvEndWriteStruct(fs); if (++asd[9] == ':') { asd[9] = '0'; asd[8]++; } }
/*! \fn CvGaborFeature::writeXML(const char* filename) const */ void CvGaborFeature::writeXML(const char* filename) const { CvMemStorage* storage = cvCreateMemStorage( 0 ); CvFileStorage* fs = cvOpenFileStorage( filename, storage, CV_STORAGE_WRITE); cvStartWriteStruct( fs, "CvGaborFeature", CV_NODE_MAP, NULL, cvAttrList(0,0)); cvWriteInt(fs, "x", getx()); cvWriteInt(fs, "y", gety()); cvWriteInt(fs, "Mu",getMu()); cvWriteInt(fs, "Nu",getNu()); cvEndWriteStruct(fs); cvEndWriteStruct( fs ); cvReleaseFileStorage(&fs); cvReleaseMemStorage(&storage); }
void KITECH_HSVColorRecognitionComp::SetDataToDB(const char* database) { char str[256]; CvFileStorage *fs = cvOpenFileStorage(database, 0, CV_STORAGE_WRITE); cvWriteInt(fs, "color_count", (int)_colorRange.size()); for( int i = 0 ; i < (int)_colorRange.size() ; i++ ) { sprintf(str, "color%d", i); cvStartWriteStruct(fs, str, CV_NODE_SEQ); cvWriteString( fs, 0, _colorRange[i].name.c_str() ); cvWriteInt( fs, 0, _colorRange[i].min1 ); cvWriteInt( fs, 0, _colorRange[i].max1 ); cvWriteInt( fs, 0, _colorRange[i].min2 ); cvWriteInt( fs, 0, _colorRange[i].max2 ); cvWriteInt( fs, 0, _colorRange[i].min3 ); cvWriteInt( fs, 0, _colorRange[i].max3 ); cvEndWriteStruct(fs); } cvReleaseFileStorage(&fs); }
int main (int argc, char **argv) { char filename[] = "save_cv.xml"; // file name int i; int a; float b; CvMat** mat; CvFileStorage *cvfs; // (1)create sample data a = 10; b = 0.1; mat = (CvMat**)cvAlloc(3*sizeof(CvMat*)); for(i=0;i<3;i++){ mat[i] = cvCreateMat(3,3,CV_32FC1); cvSet(mat[i], cvScalarAll(i), NULL); } // (2)open file storage cvfs = cvOpenFileStorage(filename,NULL,CV_STORAGE_WRITE); // (3)write data to file cvWriteInt(cvfs, "a", a); cvWriteReal(cvfs, "b", b); cvStartWriteStruct(cvfs, "mat_array", CV_NODE_SEQ, NULL, cvAttrList(NULL, NULL)); // create node for(i=0; i<3; i++){ cvWrite(cvfs, NULL, mat[i], cvAttrList(NULL, NULL)); } cvEndWriteStruct(cvfs); // (4)close file storage cvReleaseFileStorage(&cvfs); // release mat for(i=0; i<3; i++){ cvReleaseMat(mat+i); } cvFree(mat); return 0; }
void CvANN_MLP::write( CvFileStorage* fs, const char* name ) { CV_FUNCNAME( "CvANN_MLP::write" ); __BEGIN__; int i, l_count = layer_sizes->cols; if( !layer_sizes ) CV_ERROR( CV_StsError, "The network has not been initialized" ); cvStartWriteStruct( fs, name, CV_NODE_MAP, CV_TYPE_NAME_ML_ANN_MLP ); cvWrite( fs, "layer_sizes", layer_sizes ); write_params( fs ); cvStartWriteStruct( fs, "input_scale", CV_NODE_SEQ + CV_NODE_FLOW ); cvWriteRawData( fs, weights[0], layer_sizes->data.i[0]*2, "d" ); cvEndWriteStruct( fs ); cvStartWriteStruct( fs, "output_scale", CV_NODE_SEQ + CV_NODE_FLOW ); cvWriteRawData( fs, weights[l_count], layer_sizes->data.i[l_count-1]*2, "d" ); cvEndWriteStruct( fs ); cvStartWriteStruct( fs, "inv_output_scale", CV_NODE_SEQ + CV_NODE_FLOW ); cvWriteRawData( fs, weights[l_count+1], layer_sizes->data.i[l_count-1]*2, "d" ); cvEndWriteStruct( fs ); cvStartWriteStruct( fs, "weights", CV_NODE_SEQ ); for( i = 1; i < l_count; i++ ) { cvStartWriteStruct( fs, 0, CV_NODE_SEQ + CV_NODE_FLOW ); cvWriteRawData( fs, weights[i], (layer_sizes->data.i[i-1]+1)*layer_sizes->data.i[i], "d" ); cvEndWriteStruct( fs ); } cvEndWriteStruct( fs ); __END__; }
virtual void SaveState(CvFileStorage* fs) { int b,bN = m_BlobList.GetBlobNum(); cvWriteInt(fs,"BlobNum",m_BlobList.GetBlobNum()); cvStartWriteStruct(fs,"BlobList",CV_NODE_SEQ); for(b=0; b<bN; ++b) { DefBlobTrackerCR* pF = (DefBlobTrackerCR*)m_BlobList.GetBlob(b); cvStartWriteStruct(fs,NULL,CV_NODE_MAP); cvWriteInt(fs,"ID",CV_BLOB_ID(pF)); cvStartWriteStruct(fs,"Blob",CV_NODE_SEQ|CV_NODE_FLOW); cvWriteRawData(fs,&(pF->blob),1,"ffffi"); cvEndWriteStruct(fs); cvStartWriteStruct(fs,"BlobPredict",CV_NODE_SEQ|CV_NODE_FLOW); cvWriteRawData(fs,&(pF->BlobPredict),1,"ffffi"); cvEndWriteStruct(fs); cvStartWriteStruct(fs,"BlobPrev",CV_NODE_SEQ|CV_NODE_FLOW); cvWriteRawData(fs,&(pF->BlobPrev),1,"ffffi"); cvEndWriteStruct(fs); pF->pBlobHyp->Write(fs,"BlobHyp"); cvWriteInt(fs,"Collision",pF->Collision); cvStartWriteStruct(fs,"Predictor",CV_NODE_MAP); pF->pPredictor->SaveState(fs); cvEndWriteStruct(fs); cvStartWriteStruct(fs,"Resolver",CV_NODE_MAP); pF->pResolver->SaveState(fs); cvEndWriteStruct(fs); cvEndWriteStruct(fs); } cvEndWriteStruct(fs); } /* SaveState. */
// Save XML-formatted configuration file. void writeConfiguration(const char* filename, struct slParams* sl_params){ // Create file storage for XML-formatted configuration file. CvFileStorage* fs = cvOpenFileStorage(filename, 0, CV_STORAGE_WRITE); // Write output directory and object (or sequence) name. cvStartWriteStruct(fs, "output", CV_NODE_MAP); cvWriteString(fs, "output_directory", sl_params->outdir, 1); cvWriteString(fs, "object_name", sl_params->object, 1); cvWriteInt(fs, "save_intermediate_results", sl_params->save); cvEndWriteStruct(fs); // Write camera parameters. cvStartWriteStruct(fs, "camera", CV_NODE_MAP); cvWriteInt(fs, "width", sl_params->cam_w); cvWriteInt(fs, "height", sl_params->cam_h); cvWriteInt(fs, "Logitech_Quickcam_9000_raw_mode", sl_params->Logitech_9000); cvEndWriteStruct(fs); // Write projector parameters. cvStartWriteStruct(fs, "projector", CV_NODE_MAP); cvWriteInt(fs, "width", sl_params->proj_w); cvWriteInt(fs, "height", sl_params->proj_h); cvWriteInt(fs, "invert_projector", sl_params->proj_invert); cvEndWriteStruct(fs); // Write camera and projector gain parameters. cvStartWriteStruct(fs, "gain", CV_NODE_MAP); cvWriteInt(fs, "camera_gain", sl_params->cam_gain); cvWriteInt(fs, "projector_gain", sl_params->proj_gain); cvEndWriteStruct(fs); // Write distortion model parameters. cvStartWriteStruct(fs, "distortion_model", CV_NODE_MAP); cvWriteInt(fs, "enable_tangential_camera", sl_params->cam_dist_model[0]); cvWriteInt(fs, "enable_6th_order_radial_camera", sl_params->cam_dist_model[1]); cvWriteInt(fs, "enable_tangential_projector", sl_params->proj_dist_model[0]); cvWriteInt(fs, "enable_6th_order_radial_projector", sl_params->proj_dist_model[1]); cvEndWriteStruct(fs); // Write camera calibration chessboard parameters. cvStartWriteStruct(fs, "camera_chessboard", CV_NODE_MAP); cvWriteInt(fs, "interior_horizontal_corners", sl_params->cam_board_w); cvWriteInt(fs, "interior_vertical_corners", sl_params->cam_board_h); cvWriteReal(fs, "square_width_mm", sl_params->cam_board_w_mm); cvWriteReal(fs, "square_height_mm", sl_params->cam_board_h_mm); cvEndWriteStruct(fs); // Write projector calibration chessboard parameters. cvStartWriteStruct(fs, "projector_chessboard", CV_NODE_MAP); cvWriteInt(fs, "interior_horizontal_corners", sl_params->proj_board_w); cvWriteInt(fs, "interior_vertical_corners", sl_params->proj_board_h); cvWriteInt(fs, "square_width_pixels", sl_params->proj_board_w_pixels); cvWriteInt(fs, "square_height_pixels", sl_params->proj_board_h_pixels); cvEndWriteStruct(fs); // Write scanning and reconstruction parameters. cvStartWriteStruct(fs, "scanning_and_reconstruction", CV_NODE_MAP); cvWriteInt(fs, "mode", sl_params->mode); cvWriteInt(fs, "reconstruct_columns", sl_params->scan_cols); cvWriteInt(fs, "reconstruct_rows", sl_params->scan_rows); cvWriteInt(fs, "frame_delay_ms", sl_params->delay); cvWriteInt(fs, "minimum_contrast_threshold", sl_params->thresh); cvWriteReal(fs, "minimum_distance_mm", sl_params->dist_range[0]); cvWriteReal(fs, "maximum_distance_mm", sl_params->dist_range[1]); cvWriteReal(fs, "maximum_distance_variation_mm", sl_params->dist_reject); cvWriteReal(fs, "minimum_background_distance_mm", sl_params->background_depth_thresh); cvEndWriteStruct(fs); // Write visualization options. cvStartWriteStruct(fs, "visualization", CV_NODE_MAP); cvWriteInt(fs, "display_intermediate_results", sl_params->display); cvWriteInt(fs, "display_window_width_pixels", sl_params->window_w); cvEndWriteStruct(fs); // Close file storage for XML-formatted configuration file. cvReleaseFileStorage(&fs); }
void GazeTracker::save(CvFileStorage *out, const char *name) { cvStartWriteStruct(out, name, CV_NODE_MAP); Utils::saveVector(out, "calTargets", _calTargets); cvEndWriteStruct(out); }
void SaveAll() { int ObjNum = m_TrackList.GetBlobNum(); int i; char video_name[1024+1]; char* struct_name = NULL; CvFileStorage* storage = cvOpenFileStorage(m_pFileName,NULL,CV_STORAGE_WRITE_TEXT); if(storage==NULL) { printf("WARNING!!! Cannot open %s file for trajectory output.", m_pFileName); } for(i=0; i<1024 && m_pFileName[i]!='.' && m_pFileName[i]!=0; ++i) video_name[i]=m_pFileName[i]; video_name[i] = 0; for(;i>0; i--) { if(video_name[i-1] == '\\') break; if(video_name[i-1] == '/') break; if(video_name[i-1] == ':') break; } struct_name = video_name + i; cvStartWriteStruct(storage, struct_name, CV_NODE_SEQ); for(i=0; i<ObjNum; ++i) { char obj_name[1024]; DefBlobTrack* pTrack = (DefBlobTrack*)m_TrackList.GetBlob(i); if(pTrack==NULL) continue; sprintf(obj_name,"%s_obj%d",struct_name,i); cvStartWriteStruct(storage, NULL, CV_NODE_MAP); cvWriteInt(storage, "FrameBegin", pTrack->FrameBegin); cvWriteString(storage, "VideoObj", obj_name); cvEndWriteStruct( storage ); pTrack->Saved = 1; } cvEndWriteStruct( storage ); for(i=0;i<ObjNum;++i) { char obj_name[1024]; DefBlobTrack* pTrack = (DefBlobTrack*)m_TrackList.GetBlob(i); CvBlobSeq* pSeq = pTrack->pSeq; sprintf(obj_name,"%s_obj%d",struct_name,i); cvStartWriteStruct(storage, obj_name, CV_NODE_MAP); { /* Write position: */ int j; CvPoint2D32f p; cvStartWriteStruct(storage, "Pos", CV_NODE_SEQ|CV_NODE_FLOW); for(j=0;j<pSeq->GetBlobNum();++j) { CvBlob* pB = pSeq->GetBlob(j); p.x = pB->x/(m_Size.width-1); p.y = pB->y/(m_Size.height-1); cvWriteRawData(storage, &p, 1 ,"ff"); } cvEndWriteStruct( storage ); } { /* Write size: */ int j; CvPoint2D32f p; cvStartWriteStruct(storage, "Size", CV_NODE_SEQ|CV_NODE_FLOW); for(j=0; j<pSeq->GetBlobNum(); ++j) { CvBlob* pB = pSeq->GetBlob(j); p.x = pB->w/(m_Size.width-1); p.y = pB->h/(m_Size.height-1); cvWriteRawData(storage, &p, 1 ,"ff"); } cvEndWriteStruct( storage ); } cvEndWriteStruct( storage ); } cvReleaseFileStorage(&storage); } /* Save All */
void cvWriteStruct(CvFileStorage* fs, const char* name, void* addr, const char* desc, int num) { cvStartWriteStruct(fs,name,CV_NODE_SEQ|CV_NODE_FLOW); cvWriteRawData(fs,addr,num,desc); cvEndWriteStruct(fs); }
/* * Start the process of writing out frames. (Formerly this was contained in SetUpWriteToDisk) */ void BeginToWriteOutFrames(WriteOut* DataWriter){ cvStartWriteStruct(DataWriter->fs,"Frames",CV_NODE_SEQ,NULL); return; }
void Point::save(CvFileStorage *out, const char *name) const { cvStartWriteStruct(out, name, CV_NODE_MAP); cvWriteReal(out, "x", x); cvWriteReal(out, "y", y); cvEndWriteStruct(out); }
/* * Writes Out information of one frame of the worm to a disk * in YAML format. * * Note the Worm object must have the following fields * Worm->frameNum * Worm->Segmented->Head * Worm->Segmented->Tail * Worm->Segmented->LeftBound * Worm->Segmented->RightBound * Worm->Segmented->Centerline * * and Params object must have * Params->DLPOn * Params->IllumSegCenter * Params->IllumSegRadius * Params->IllumLRC * * And more now! */ int AppendWormFrameToDisk(WormAnalysisData* Worm, WormAnalysisParam* Params, WriteOut* DataWriter){ CvFileStorage* fs=DataWriter->fs; cvStartWriteStruct(fs,NULL,CV_NODE_MAP,NULL); /** Frame Number Info **/ cvWriteInt(fs,"FrameNumber",Worm->frameNum); /** TimeStamp **/ cvWriteInt(fs,"sElapsed",GetSeconds(Worm->timestamp)); cvWriteInt(fs,"msRemElapsed",GetMilliSeconds(Worm->timestamp)); /** Segmentation Info **/ if(cvPointExists(Worm->Segmented->Head)){ cvStartWriteStruct(fs,"Head",CV_NODE_MAP,NULL); cvWriteInt(fs,"x",Worm->Segmented->Head->x); cvWriteInt(fs,"y",Worm->Segmented->Head->y); cvEndWriteStruct(fs); } if(cvPointExists(Worm->Segmented->Tail)){ cvStartWriteStruct(fs,"Tail",CV_NODE_MAP,NULL); cvWriteInt(fs,"x",Worm->Segmented->Tail->x); cvWriteInt(fs,"y",Worm->Segmented->Tail->y); cvEndWriteStruct(fs); } if(cvSeqExists(Worm->Segmented->LeftBound)) cvWrite(fs,"BoundaryA",Worm->Segmented->LeftBound); if(cvSeqExists(Worm->Segmented->RightBound)) cvWrite(fs,"BoundaryB",Worm->Segmented->RightBound); if(cvSeqExists(Worm->Segmented->Centerline)) cvWrite(fs,"SegmentedCenterline",Worm->Segmented->Centerline); /** Illumination Information **/ cvWriteInt(fs,"DLPIsOn",Params->DLPOn); cvWriteInt(fs,"FloodLightIsOn",Params->IllumFloodEverything); cvWriteInt(fs,"IllumInvert",Params->IllumInvert); cvWriteInt(fs,"IllumFlipLR",Params->IllumFlipLR); CvPoint origin=ConvertSlidlerToWormSpace(Params->IllumSquareOrig,Params->DefaultGridSize); cvStartWriteStruct(fs,"IllumRectOrigin",CV_NODE_MAP,NULL); cvWriteInt(fs,"x",origin.x); cvWriteInt(fs,"y",origin.y); cvEndWriteStruct(fs); cvStartWriteStruct(fs,"IllumRectRadius",CV_NODE_MAP,NULL); cvWriteInt(fs,"x",Params->IllumSquareRad.width); cvWriteInt(fs,"y",Params->IllumSquareRad.height); cvEndWriteStruct(fs); if (Params->stageTrackingOn){ cvStartWriteStruct(fs,"StageVelocity",CV_NODE_MAP,NULL); cvWriteInt(fs,"i",Worm->stageVelocity.x); cvWriteInt(fs,"j",Worm->stageVelocity.y); cvEndWriteStruct(fs); } /** Protocol Information **/ cvWriteInt(fs,"ProtocolIsOn",Params->ProtocolUse); cvWriteInt(fs,"ProtocolStep",Params->ProtocolStep); cvEndWriteStruct(fs); return 0; }