/**
* 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;
}