template <> bool DataOutputNode<lbfloat>::mat_write(std::string file_path, std::string var_name) { //Copy data to buffer lbfloat* buf = nullptr; size_t buf_size; contract(buf,buf_size,false); std::cout << "Output matrix will be [" << _n_samples << "] x [" << _n_channels << "]." << std::endl; //setup the output mat_t *mat; matvar_t *matvar; size_t dims[2] = {_n_samples,_n_channels}; mat = Mat_Open(file_path.c_str(),MAT_ACC_RDWR); if(mat) { //output matrix matvar = Mat_VarCreate(var_name.c_str(),MAT_C_DOUBLE,MAT_T_DOUBLE,2,dims,buf,0); Mat_VarWrite(mat, matvar, MAT_COMPRESSION_NONE); Mat_Close(mat); Mat_VarFree(matvar); std::cout << "Output data to " << var_name << " variable in file " << file_path << "!" << std::endl; delete [] buf; return true; } std::cerr << "Couldn't output to file." << std::endl; delete [] buf; return false; }
static np::ndarray bnread( const std::string & name ) { np::ndarray r(np::empty(make_tuple(0), np::dtype::get_builtin<unsigned char>())); mat_t * mat = Mat_Open(name.c_str(),MAT_ACC_RDONLY); if(mat) { matvar_t * gt = Mat_VarRead( mat, (char*)"groundTruth" ); if(!gt) return r; int nSeg = gt->dims[1]; if(!nSeg) return r; for( int s = 0; s < nSeg; s++ ) { matvar_t * cl = Mat_VarGetCell(gt, s); matvar_t * bnd = Mat_VarGetStructField( cl, (void*)"Boundaries", MAT_BY_NAME, 0 ); int W = bnd->dims[1], H = bnd->dims[0]; if( bnd->data_type != MAT_T_UINT8 ) printf("Unexpected boundary type! Continuing in denial and assuming uint8_t\n"); if( r.shape(0) <= 0 ) r = np::empty(make_tuple(nSeg,H,W), np::dtype::get_builtin<unsigned char>()); assert( r.shape(1) == H && r.shape(2) == W ); const unsigned char * pdata = static_cast<const unsigned char*>(bnd->data); unsigned char * pr = reinterpret_cast<unsigned char*>(r.get_data()+s*W*H); for( int j=0; j<H; j++ ) for( int i=0; i<W; i++ ) pr[j*W+i] = pdata[i*H+j]; } Mat_VarFree( gt ); Mat_Close(mat); } return r; }
static std::tuple< std::vector<RMatrixXs>, std::vector<RMatrixXb> > readMat( const std::string & name ) { std::vector<RMatrixXs> seg; std::vector<RMatriXb> bnd; mat_t * mat = Mat_Open(name.c_str(),MAT_ACC_RDONLY); if(mat) { matvar_t * gt = Mat_VarRead( mat, (char*)"groundTruth" ); if(!gt) return std::make_tuple(seg,bnd); int nSeg = gt->dims[1]; if(!nSeg) return std::make_tuple(seg,bnd); for( int s = 0; s < nSeg; s++ ) { const char * names[2] = {"Segmentation","Boundaries"}; const int types[2] = {MAT_T_UINT16,MAT_T_UINT8}; for( int it=0; it<2; it++ ) { matvar_t * cl = Mat_VarGetCell(gt, s); matvar_t * arr = Mat_VarGetStructField( cl, (void*)names[it], MAT_BY_NAME, 0 ); int W = arr->dims[1], H = arr->dims[0]; if( arr->data_type != types[it] ) printf("Unexpected %s type! Continuing in denial ...\n",names[it]); if(it==0) seg.push_back( MatrixXus::Map((const uint16_t*)arr->data,H,W)-1 ); else bnd.push_back( RMatrixXb::Map((const bool*)arr->data,H,W) ); } } Mat_VarFree( gt ); Mat_Close(mat); } return std::make_tuple(seg,bnd); }
/** \brief save Array-struct as MATLAB .mat file. Currently, the function converts all arrays to double-arrays. Should be easy to implement for arbitrary types if needed. \param a the Array \param varname MATLAB-name of the array \param file the filename \param append if TRUE, the function tries to open() the file, else it is overwritten \return error code */ int write_array_matlab( const Array *a, const char *varname, const char *file, bool append ){ mat_t *mfile; matvar_t *marr=NULL; int i; if( append ){ if( !(mfile=Mat_Open( file, MAT_ACC_RDWR )) ){ errprintf("Could not open '%s', creating new file\n", file); } } if( !mfile ){ if( !(mfile=Mat_Create( file, NULL )) ){ errprintf("Could not open '%s' for writing\n", file); return -1; } } int ndim = MAX(2, a->ndim); int *size = (int*)malloc( ndim*sizeof(int)); if( a->ndim==1 ){ size[0]=1; size[1]=a->size[0]; } else { memcpy( size, a->size, ndim*sizeof(int)); } dprintf("Writing to file '%s' variable '%s', ndim=%i\n", file, varname, ndim); /* convert to column major for MATLAB */ Array *b=array_convert_rowcolmajor( (Array*)a, TRUE ); dprintf("Up-cast, b->ndim=%i, b->size=%p, b->size[0]=%i\n", b->ndim, b->size, b->size[0]); /* up-cast to DOUBLE - copy of b */ Array *c=array_new( DOUBLE, b->ndim, b->size ); dprintf("casting\n"); for( i=0; i<array_NUMEL(b); i++ ){ array_dtype_to_double( array_INDEXMEM1(c,i), array_INDEXMEM1(b,i), b->dtype ); } array_free( b ); dprintf("Creating MATLAB-rep\n"); marr = Mat_VarCreate( varname, MAT_C_DOUBLE, MAT_T_DOUBLE, ndim, size, c->data, MEM_CONSERVE /* Array remains owner */ ); dprintf("mfile=%p, marr=%p, rank=%i,\n", mfile, marr, marr->rank ); int succ=Mat_VarWrite( mfile, marr, 0 ); dprintf("done writing with succ=%i\n", succ); Mat_Close( mfile ); Mat_VarFree( marr ); array_free( c ); free( size ); return 0; }
/* * matWrite - write signals from measurement structure to MAT file */ int matWrite(measurement_t *measurement, const char *outFileName) { size_t dims[2]; int err = 0; mat_t *mat; matvar_t *matvar; mat = Mat_Create(outFileName, NULL); if (mat != NULL) { /* loop over all time series */ struct hashtable *timeSeriesHash = measurement->timeSeriesHash; /* Iterator constructor only returns a valid iterator if * the hashtable is not empty */ if (hashtable_count(timeSeriesHash) > 0) { struct hashtable_itr *itr = hashtable_iterator(timeSeriesHash); do { char *signalName = hashtable_iterator_key(itr); timeSeries_t *timeSeries = hashtable_iterator_value(itr); double *timeValue = (double *)malloc(sizeof(double)*2*timeSeries->n); unsigned int i; /* * build up a 1x2n array with time stamps in [0..n-1] and * values in [n..2n-1]. */ for(i=0;i<timeSeries->n;i++) { timeValue[i] = timeSeries->time[i]; } for(i=0;i<timeSeries->n;i++) { timeValue[timeSeries->n + i] = timeSeries->value[i]; } dims[0] = timeSeries->n; dims[1] = 2; /* output signal to mat structure and free up temp array. */ matvar = Mat_VarCreate(signalName, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, timeValue, 0); Mat_VarWrite(mat, matvar, 0); Mat_VarFree(matvar); free(timeValue); } while (hashtable_iterator_advance(itr)); free(itr); } Mat_Close(mat); } else { fprintf(stderr, "error: could not create MAT file %s\n", outFileName); err = 1; } return err; }
static int ismat( const char *filename ) { mat_t *mat; if( !(mat = Mat_Open( filename, MAT_ACC_RDONLY )) ) return( 0 ); Mat_Close( mat ); return( 1 ); }
int vips__mat_ismat( const char *filename ) { mat_t *mat; vips_error_freeze(); mat = Mat_Open( filename, MAT_ACC_RDONLY ); Mat_Close( mat ); vips_error_thaw(); return( mat != NULL ); }
double *read_mat(const char *filename, const char *varname, size_t *dims) { mat_t *mat; matvar_t *var; double *array; size_t nbytes; mat = Mat_Open(filename, MAT_ACC_RDONLY); if (!mat) { fprintf(stderr, "Error opening MAT file \"%s\"!\n", filename); exit(EXIT_FAILURE); } var = Mat_VarRead(mat, varname); if (!var) { fprintf(stderr, "Error reading the variable %s.\n", varname); Mat_Close(mat); exit(EXIT_FAILURE); } if (var->data_type != MAT_T_DOUBLE || var->class_type != MAT_C_DOUBLE || var->rank != 2) { fprintf(stderr, "%s is not a double-precision matrix.\n", varname); Mat_VarFree(var); Mat_Close(mat); exit(EXIT_FAILURE); } nbytes = var->dims[0] * var->dims[1] * sizeof(double); array = (double *)malloc(nbytes); memcpy(array, var->data, nbytes); memcpy(dims, var->dims, 2 * sizeof(size_t)); Mat_VarFree(var); Mat_Close(mat); return array; }
// save a .mat matlab matrix // will store a single matrix (sparse or dense) in a .mat file // returns 0 on success static int write_mat(char const *const filename, matrix_t *const A) { #ifndef HAVE_MATIO return 1; #else const char created_by[] = "created by " PACKAGE_STRING; // "created by Meagre-Crowd x.y.z" mat_t* matfp; matfp = Mat_Create(filename, created_by); if(matfp == NULL) return 1; // failed to open file // create a matrix convert into matvar_t* t = NULL; int ret = 0; if(A->format == DCOL || A->format == DROW) { // dense ret = convert_matrix(A, DCOL, FIRST_INDEX_ZERO); // DROW -> DCOL if DROW if(ret != 0) ret = 2; // conversion failure if(ret == 0) { // TODO check for integer overflow in cast from unsigned int -> int size_t dims[] = { A->m, A->n }; t = Mat_VarCreate( "x", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, // always at least rank 2 dims, A->dd, 0 // MAT_F_COMPLEX if complex, could avoid copying data: MAT_F_DONT_COPY_DATA if not sparse ); if(t == NULL) { ret = 3; // failed to malloc data for storage } else { ret = Mat_VarWrite(matfp, t, 1); // compress if(ret != 0) ret = 4; // failed data write } } } else { // sparse assert(0); // do we ever get sparse results? } Mat_Close(matfp); Mat_VarFree(t); return ret; // success? #endif }
void write_mat(const char *filename, const char *varname, double *array, size_t *dims) { mat_t *mat; matvar_t *var; mat = Mat_CreateVer(filename, NULL, MAT_FT_DEFAULT); if (!mat) { fprintf(stderr, "Error creating MAT file \"%s\"\n", filename); exit(EXIT_FAILURE); } var = Mat_VarCreate(varname, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, array, 0); if (!var) { fprintf(stderr, "Error creating variable %s.\n", varname); Mat_Close(mat); exit(EXIT_FAILURE); } Mat_VarWrite(mat, var, MAT_COMPRESSION_NONE); Mat_VarFree(var); Mat_Close(mat); }
bool annoRead(std::string annoName, BOWImg &dst) { mat_t *matfp = Mat_Open(annoName.c_str(),MAT_ACC_RDONLY); if(matfp == NULL) { std::cerr<<"Cannot open file '"<<annoName<<"'."<<std::endl; return false; } char varName[] = "box_coord"; readNumber<int>(matfp,varName,dst.box); //readNumber<double>(matfp,"obj_contour",dst.objContour); Mat_Close(matfp); return true; }
TData read_data() { const char * fileName = "../data/mnist_uint8.mat"; TData res; mat_t *mat = nullptr; scope_guard _l([&mat, fileName](){ mat = Mat_Open(fileName, MAT_ACC_RDONLY); }, [&mat](){Mat_Close(mat);}); if(!mat){ std::cout <<"cannot open "<<fileName<<std::endl; return res; } matvar_t *var = 0; int read_items = 0; while((var = Mat_VarReadNextInfo(mat)) != nullptr){ if(strcmp(var->name, "train_x") == 0) { res.train_x = read_matrix_in_mat(mat, var->name); read_items ++ ; } else if(strcmp(var->name, "train_y") == 0) { res.train_y = read_matrix_in_mat(mat, var->name); read_items ++; } else if(strcmp(var->name, "test_x") == 0) { res.test_x = read_matrix_in_mat(mat, var->name); read_items ++; } else if(strcmp(var->name, "test_y" ) == 0) { res.test_y = read_matrix_in_mat(mat, var->name); read_items ++; } else{ //nothing here, just for fun... } Mat_VarFree(var); } if(read_items != 4) { std::cout<<"ooooooops, cannot read "<< fileName<<std::endl; } return res; }
template <> bool DataOutputNode<lbcomplex>::mat_write(std::string file_path, std::string var_name) { //Copy data to buffer lbcomplex* buf = nullptr; size_t buf_size; contract(buf,buf_size,false); std::cout << "Output matrix will be [" << _n_samples << "] x [" << _n_channels << "]." << std::endl; //setup the output mat_t *mat; matvar_t *matvar; mat_complex_split_t data; data.Re = malloc(buf_size*sizeof(lbfloat)); data.Im = malloc(buf_size*sizeof(lbfloat)); for(size_t ii=0; ii<buf_size; ++ii) { reinterpret_cast<lbfloat*>(data.Re)[ii] = std::real(buf[ii]); reinterpret_cast<lbfloat*>(data.Im)[ii] = std::imag(buf[ii]); } size_t dims[2] = {_n_samples,_n_channels}; mat = Mat_Open(file_path.c_str(),MAT_ACC_RDWR); if(mat) { //output matrix matvar = Mat_VarCreate(var_name.c_str(),MAT_C_DOUBLE,MAT_T_DOUBLE,2,dims,&data,MAT_F_COMPLEX); Mat_VarWrite(mat, matvar, MAT_COMPRESSION_NONE); Mat_Close(mat); Mat_VarFree(matvar); std::cout << "Output data to " << var_name << " variable in file " << file_path << "!" << std::endl; delete [] buf; return true; } std::cerr << "Couldn't output to file." << std::endl; delete [] buf; return false; }
// Default destructor MatFileIO::~MatFileIO() { Mat_Close(mat); }
int main (int argc, char *argv[]){ char **str2,*line,*curr; const char* ext=".exo"; int i,j,k,n,n1,cpu_word_size,io_word_size,exo_file, num_axes,num_nodes,num_elements,num_blocks, num_side_sets,num_node_sets,num_time_steps, num_global_vars, num_nodal_vars,num_element_vars,*ids,*iscr, *nsssides,*nssdfac,*elem_list,*side_list, *nnsnodes,*nnsdfac,*node_list; double *scr,*x,*y,*z, *escr; char * blknames = NULL; int *num_elem_in_block = NULL; /* QA Info */ printf("%s: %s, %s\n", qainfo[0], qainfo[2], qainfo[1]); /* usage message*/ if(argc != 2){ printf("%s matlab_file_name.\n",argv[0]); printf(" the matlab_file_name is required\n"); printf("%d", argc); exit(1); } /*open input file*/ mat_file = Mat_Open(argv[1], MAT_ACC_RDONLY); if (mat_file == NULL) { printf("Error opening matlab file %s\n", argv[1]); return(1); } /*open output file*/ cpu_word_size=sizeof(double); io_word_size=sizeof(double); /* QA records */ ext=".exo"; line = (char *) calloc (2049,sizeof(char)); strcpy(line,argv[1]); strtok(line,"."); strcat(line,ext); exo_file = ex_create(line,EX_CLOBBER,&cpu_word_size,&io_word_size); if (exo_file < 0){ printf("error creating %s\n",line); exit(1); } /* print */ fprintf(stderr,"translating %s to %s ... ",argv[1],line); /* read database parameters */ matGetInt("naxes", 1, 1,&num_axes); matGetInt("nnodes", 1, 1,&num_nodes); matGetInt("nelems", 1, 1,&num_elements); matGetInt("nblks", 1, 1,&num_blocks); matGetInt("nnsets", 1, 1,&num_node_sets); matGetInt("nssets", 1, 1,&num_side_sets); matGetInt("nsteps", 1, 1,&num_time_steps); matGetInt("ngvars", 1, 1,&num_global_vars); matGetInt("nnvars", 1, 1,&num_nodal_vars); matGetInt("nevars", 1, 1,&num_element_vars); /*export parameters */ ex_put_init(exo_file,line, num_axes,num_nodes,num_elements,num_blocks, num_node_sets,num_side_sets); free(line); if ( num_global_vars > 0 ){ ex_put_variable_param(exo_file,EX_GLOBAL,num_global_vars); } if ( num_nodal_vars > 0 ){ ex_put_variable_param(exo_file,EX_NODAL,num_nodal_vars); } if ( num_element_vars > 0 ){ ex_put_variable_param(exo_file,EX_ELEM_BLOCK,num_element_vars); } /* nodal coordinates */ x = (double *) calloc(num_nodes,sizeof(double)); y = (double *) calloc(num_nodes,sizeof(double)); if (num_axes == 3) z = (double *) calloc(num_nodes,sizeof(double)); else z = NULL; matGetDbl("x0", num_nodes, 1, x); matGetDbl("y0", num_nodes, 1, y); if (num_axes == 3) matGetDbl("z0", num_nodes,1,z); ex_put_coord(exo_file,x,y,z); free(x); free(y); if (num_axes == 3){ free(z); } /* side sets (section by dgriffi) */ if(num_side_sets > 0){ /* ssids */ ids = (int *) calloc(num_side_sets,sizeof(int)); matGetInt("ssids",num_side_sets, 1,ids); /* nsssides */ nsssides = (int *) calloc(num_side_sets,sizeof(int)); matGetInt("nsssides",num_side_sets,1,nsssides); /* nssdfac */ nssdfac = (int *) calloc(num_side_sets,sizeof(int)); matGetInt("nssdfac",num_side_sets,1,nssdfac); for(i=0;i<num_side_sets;i++){ char name[32]; ex_put_set_param(exo_file,EX_SIDE_SET,ids[i],nsssides[i],nssdfac[i]); elem_list = (int *) calloc(nsssides[i],sizeof(int)); side_list = (int *) calloc(nsssides[i],sizeof(int)); escr = (double *) calloc(nssdfac[i],sizeof(double)); sprintf(name,"sselem%02d",i+1); matGetInt(name,nsssides[i],1,elem_list); sprintf(name,"ssside%02d",i+1); matGetInt(name,nsssides[i],1,side_list); ex_put_set(exo_file,EX_SIDE_SET,ids[i],elem_list,side_list); free(elem_list); free(side_list); sprintf(name,"ssfac%02d",i+1); matGetDbl(name,nssdfac[i],1,escr); ex_put_set_dist_fact(exo_file,EX_SIDE_SET,ids[i],escr); free(escr); } free(nsssides); free(nssdfac); free(ids); } /* node sets (section by dgriffi) */ if(num_node_sets > 0){ /* nsids */ ids = (int *) calloc(num_node_sets,sizeof(int)); matGetInt("nsids",num_node_sets, 1,ids); /* nnsnodes */ nnsnodes = (int *) calloc(num_node_sets,sizeof(int)); matGetInt("nnsnodes",num_node_sets,1,nnsnodes); /* nnsdfac */ nnsdfac = (int *) calloc(num_node_sets,sizeof(int)); matGetInt("nnsdfac",num_node_sets,1,nnsdfac); for(i=0;i<num_node_sets;i++){ char name[32]; ex_put_set_param(exo_file,EX_NODE_SET,ids[i],nnsnodes[i],nnsdfac[i]); node_list = (int *) calloc(nnsnodes[i],sizeof(int)); escr = (double *) calloc(nnsdfac[i],sizeof(double)); sprintf(name,"nsnod%02d",i+1); matGetInt(name,nnsnodes[i],1,node_list); ex_put_set(exo_file,EX_NODE_SET,ids[i],node_list,NULL); free(node_list); sprintf(name,"nsfac%02d",i+1); matGetDbl(name,nnsdfac[i],1,escr); ex_put_set_dist_fact(exo_file,EX_NODE_SET,ids[i],escr); free(escr); } free(nnsdfac); free(nnsnodes); free(ids); } /* element blocks */ /* get elem block ids */ ids = (int *) calloc(num_blocks,sizeof(int)); matGetInt("blkids",num_blocks,1,ids); /* get elem block types */ blknames = (char *) calloc(num_blocks*(MAX_STR_LENGTH+1),sizeof(char)); matGetStr("blknames",blknames); num_elem_in_block = (int *) calloc(num_blocks,sizeof(int)); curr = blknames; curr = strtok(curr,"\n"); for(i=0;i<num_blocks;i++){ char name[32]; sprintf(name,"blk%02d",i+1); n1 = matArrNRow(name); n = matArrNCol(name); iscr = (int *) calloc(n*n1,sizeof(int)); matGetInt(name,n1,n,iscr); num_elem_in_block[i]=n; ex_put_elem_block(exo_file,ids[i],curr,n,n1,0); ex_put_conn(exo_file,EX_ELEM_BLOCK,ids[i],iscr,NULL,NULL); free(iscr); curr = strtok(NULL, "\n"); } free(blknames); /* time values */ if (num_time_steps > 0 ) { scr = (double *) calloc(num_time_steps,sizeof(double)); matGetDbl( "time", num_time_steps, 1,scr); for (i=0;i<num_time_steps;i++){ ex_put_time(exo_file,i+1,&scr[i]); } free(scr); } /* global variables */ if (num_global_vars > 0 ){ int max_name_length = ex_inquire_int(exo_file, EX_INQ_DB_MAX_USED_NAME_LENGTH); char *str = (char *) calloc(num_global_vars * (max_name_length+1), sizeof(char)); matGetStr("gnames",str); str2 = (char **) calloc(num_global_vars,sizeof(char*)); curr = strtok(str,"\n"); for(i=0;i<num_global_vars;i++){ str2[i]=curr; curr = strtok(NULL,"\n"); } ex_put_variable_names(exo_file, EX_GLOBAL, num_global_vars, str2); free(str); free(str2); { double * global_var_vals; double * temp; global_var_vals = (double *) calloc(num_global_vars*num_time_steps,sizeof(double)); temp = (double *) calloc(num_time_steps,sizeof(double)); for (j=0;j<num_global_vars;j++) { char name[32]; sprintf(name,"gvar%02d",j+1); matGetDbl(name,num_time_steps,1,temp); for (i=0; i < num_time_steps; i++) { global_var_vals[num_global_vars*i+j]=temp[i]; } } for (i=0; i<num_time_steps; i++) { size_t offset = num_global_vars * i; ex_put_var(exo_file,i+1,EX_GLOBAL,1,0,num_global_vars,&global_var_vals[offset]); } free(temp); free(global_var_vals); } } /* nodal variables */ /* section by dtg */ if (num_nodal_vars > 0){ int max_name_length = ex_inquire_int(exo_file, EX_INQ_DB_MAX_USED_NAME_LENGTH); char *str = (char *) calloc(num_nodal_vars * (max_name_length+1), sizeof(char)); matGetStr("nnames",str); str2 = (char **) calloc(num_nodal_vars,sizeof(char*)); curr = strtok(str,"\n"); for(i=0;i<num_nodal_vars;i++){ str2[i]=curr; curr = strtok(NULL,"\n"); } ex_put_variable_names(exo_file, EX_NODAL, num_nodal_vars, str2); free(str); free(str2); { double * nodal_var_vals; for (i=0;i<num_nodal_vars;i++) { char name[32]; nodal_var_vals = (double *) calloc(num_nodes*num_time_steps,sizeof(double)); sprintf(name,"nvar%02d",i+1); matGetDbl(name,num_nodes,num_time_steps,nodal_var_vals); for (j=0;j<num_time_steps;j++) { ex_put_var(exo_file,j+1,EX_NODAL,i+1,num_nodes,1,nodal_var_vals+num_nodes*j); } free(nodal_var_vals); } } } /* elemental variables */ /* section by dtg */ if (num_element_vars > 0){ int max_name_length = ex_inquire_int(exo_file, EX_INQ_DB_MAX_USED_NAME_LENGTH); char *str = (char *) calloc(num_element_vars * (max_name_length+1), sizeof(char)); matGetStr("enames",str); str2 = (char **) calloc(num_element_vars,sizeof(char*)); curr = strtok(str,"\n"); for(i=0;i<num_element_vars;i++){ str2[i]=curr; curr = strtok(NULL,"\n"); } ex_put_variable_names(exo_file, EX_ELEM_BLOCK, num_element_vars, str2); free(str); free(str2); { double * element_var_vals; for (i=0;i<num_element_vars;i++) { char name[32]; element_var_vals = (double *) calloc(num_elements*num_time_steps,sizeof(double)); sprintf(name,"evar%02d",i+1); matGetDbl(name,num_elements,num_time_steps,element_var_vals); n=0; for (j=0;j<num_time_steps;j++) { for (k=0;k<num_blocks;k++) { ex_put_var(exo_file,j+1,EX_ELEM_BLOCK, i+1,ids[k],num_elem_in_block[k],element_var_vals+n); n=n+num_elem_in_block[k]; } } free(element_var_vals); } } } free(ids); /* node and element number maps */ ids = (int *) calloc (num_nodes,sizeof(int)); if ( !matGetInt("node_num_map",num_nodes,1,ids)){ ex_put_node_num_map(exo_file,ids); } free(ids); ids = (int *) calloc (num_elements,sizeof(int)); if ( !matGetInt("elem_num_map",num_elements,1,ids)){ ex_put_elem_num_map(exo_file,ids); } free(ids); free(num_elem_in_block); /* close exo file */ ex_close(exo_file); /* close mat file */ Mat_Close(mat_file); /* */ fprintf(stderr,"done.\n"); /* exit status */ add_to_log("mat2exo", 0); return(0); }
int main (int argc, char *argv[]) { char *prog_name = "matdump"; int i, c, err = EXIT_SUCCESS; mat_t *mat; matvar_t *matvar; int version[3]; Mat_GetLibraryVersion(version, version+1, version+2); if ( MATIO_MAJOR_VERSION != version[0] || MATIO_MINOR_VERSION != version[1] || MATIO_RELEASE_LEVEL != version[2] ) { fprintf(stderr,"matio version in header does not match runtime " "version\n"); return EXIT_FAILURE; } Mat_LogInitFunc(prog_name,default_printf_func); printfunc = print_default; while ((c = getopt_long(argc,argv,optstring,options,NULL)) != EOF) { switch (c) { case 'd': printdata = 1; Mat_VerbMessage(1,"Printing data\n"); break; case 'f': if ( NULL != optarg && !strcmp(optarg,"whos") ) { printfunc = print_whos; break; } Mat_Warning("%s is not a recognized output format. " "Using default\n", optarg); break; case 'h': human_readable = 1; break; case 'v': Mat_SetVerbose(1,0); break; case 'H': Mat_Help(helpstr); exit(EXIT_SUCCESS); case 'V': printf("%s %s\nWritten by Christopher Hulbert\n\n" "Copyright(C) 2006-2013 Christopher C. Hulbert\n", prog_name,MATIO_VERSION_STR); exit(EXIT_SUCCESS); default: printf("%c not a valid option\n", c); break; } } if ( (argc-optind) < 1 ) Mat_Error("Must specify at least one argument"); mat = Mat_Open( argv[optind],MAT_ACC_RDONLY ); if ( NULL == mat ) { Mat_Error("Error opening %s\n", argv[optind]); return EXIT_FAILURE; } optind++; if ( optind < argc ) { /* variables specified on the command line */ for ( i = optind; i < argc; i++ ) { char *next_tok_pos, next_tok = 0; next_tok_pos = get_next_token(argv[i]); if ( next_tok_pos != argv[i] ) { next_tok = *next_tok_pos; *next_tok_pos = '\0'; } matvar = Mat_VarReadInfo(mat,argv[i]); if ( matvar ) { if ( printdata ) { if ( next_tok == '\0' ) { /* No indexing tokens found, so read all of the data */ Mat_VarReadDataAll(mat,matvar); } else { *next_tok_pos = next_tok; read_selected_data(mat,matvar,next_tok_pos); } } (*printfunc)(matvar); Mat_VarFree(matvar); matvar = NULL; } else { Mat_Warning("Couldn't find variable %s in the MAT file", argv[i]); } } /* for ( i = optind; i < argc; i++ ) */ } else { /* print all variables */ if ( printdata ) { while ( (matvar = Mat_VarReadNext(mat)) != NULL ) { (*printfunc)(matvar); Mat_VarFree(matvar); matvar = NULL; } } else { while ( (matvar = Mat_VarReadNextInfo(mat)) != NULL ) { (*printfunc)(matvar); Mat_VarFree(matvar); matvar = NULL; } } } Mat_Close(mat); Mat_LogClose(); return err; }
int main(int argn, char **argc){ if(argn != 3){ printf("usage: convert infile.bin outfile.mat\n"); exit(0); } else { FILE* in = fopen(argc[1], "r"); if(!in) { printf("could not open %s\n", argc[1]); exit(0); } mat_t *mat; mat = Mat_Create(argc[2],NULL); if(!mat){ printf("could not open for writing %s\n", argc[2]); exit(0); } //this is (for now) a two-stage process: //have to scan through the file, //determine what's there, allocate memory appropritately, //then fill those structures up and write *that* out. unsigned int u; unsigned int pos = 0; unsigned int rxpackets = 0; unsigned int txpackets = 0; unsigned int msgpackets = 0; bool done = false; while(!done){ fread((void*)&u,4,1,in); if(ferror(in) || feof(in)) done = true; else { if(u == 0xdecafbad){ fread((void*)&u,4,1,in); unsigned int siz = u & 0xffff; //printf("u 0x%x\n",u); rxpackets += (siz-4)/(32+4); fseek(in,siz+8, SEEK_CUR); pos += 16+siz; }else if(u == 0xc0edfad0){ fread((void*)&u,4,1,in); unsigned int siz = u & 0xffff; //printf("u 0x%x\n",u); txpackets++; fseek(in,siz+8, SEEK_CUR); pos += 16+siz; }else if(u == 0xb00a5c11){ fread((void*)&u,4,1,in); unsigned int siz = u & 0xffff; //printf("u 0x%x\n",u); msgpackets += 1; fseek(in,siz+8, SEEK_CUR); pos += 16+siz; } else { printf("magic number seems off, is 0x%x, %d bytes, %d packets\n", u,pos,rxpackets); exit(0); } if(ferror(in) || feof(in)) done = true; } } printf("total %d rxpackets, %d txpackets, %d messages\n", rxpackets, txpackets, msgpackets); fseek(in,0, SEEK_SET); //okay, allocate appropriate data structs: // time (double), analog(i8), channel (i8), // spike_time (double), spikes(i32) double* time; mat_uint32_t* mstimer; mat_int8_t* analog; mat_int8_t* channel; mat_uint32_t* spike_ts; mat_int8_t* spike_ch; mat_int8_t* spike_unit; // store timestamp (in samples), rx time (not necessarily accurate) - one per pkt // store channel # and sample // store channel & timestamp for spikes. // just ignore dropped packets for now. time = (double*)malloc(rxpackets * sizeof(double)); if(!time){ printf("could not allocate time variable."); exit(0);} mstimer = (mat_uint32_t*)malloc(rxpackets * sizeof(int) ); if(!mstimer){ printf("could not allocate mstimer variable."); exit(0);} analog = (mat_int8_t*)malloc(rxpackets * 24 ); if(!analog){ printf("could not allocate analog variable."); exit(0);} channel = (mat_int8_t*)malloc(rxpackets * 24 ); if(!channel){ printf("could not allocate channel variable."); exit(0);} spike_ts = (mat_uint32_t*)malloc(rxpackets * sizeof(int)*32); if(!spike_ts){ printf("could not allocate spike_ts variable."); exit(0);} spike_ch = (mat_int8_t*)malloc(rxpackets * 32); if(!spike_ch){ printf("could not allocate spike_ch variable."); exit(0);} spike_unit = (mat_int8_t*)malloc(rxpackets * 32); if(!spike_unit){ printf("could not allocate spike_unit variable."); exit(0);} //also need to inspect the messages, to see exactly when the channels changed. rxpackets = 0; int tp = 0; // packet position (index time, aka timestamp) int sp = 0; // spike position (index spike variables) char msgs[16][128]; //use this to save messages ; appy them when their echo appears. for(int i=0; i<16*128; i++){ msgs[0][i] = 0; //yes, you can do that in c! } int chans[4] = {0,32,64,96}; done = false; while(!done){ fread((void*)&u,4,1,in); if(ferror(in) || feof(in)) done = true; else { if(u == 0xdecafbad){ fread((void*)&u,4,1,in); unsigned int siz = u & 0xffff; int npak = (siz-4)/(4+32); //first 4 is for dropped packet count //second 4 is for 4 byte bridge milisecond counter //printf("npak %d siz %d\n",npak,siz); double rxtime = 0.0; unsigned int dropped = 0; fread((void*)&rxtime,8,1,in); //rx time in seconds. fread((void*)&dropped,4,1,in); int channels[32]; char match[32]; for(int i=0;i<npak; i++){ packet p; fread((void*)&p,sizeof(p),1,in); if(ferror(in) || feof(in)) done = true; else{ /*int headecho = ((p.flag) >> 4) & 0xf; //check to see if we can apply the command that was echoed. char m = msgs[headecho][0]; if(m >= 'A' && m <= 'A' + 15){ printf("applying %s\n", msgs[headecho]); msgs[headecho][0] = 0; }*/ time[tp] = rxtime + (double)i * 6.0 / 31250.0; mstimer[tp] = p.ms; for(int j=0; j<6; j++){ for(int k=0; k<4; k++){ char samp = p.data[j*4+k]; analog[tp*24+j*4+k] = samp; channel[tp*24+j*4+k] = chans[k]; } } decodePacket(&p, channels, match); for(int j=0; j<32; j++){ if(match[j]){ spike_ts[sp] = tp; spike_ch[sp] = channel[j]; spike_unit[sp] = match[j]; sp++; } } tp++; } } pos += 16+siz; } else if( u == 0xc0edfad0){ //ignore tx packets (for now?) fread((void*)&u,4,1,in); unsigned int siz = u & 0xffff; //printf("u 0x%x\n",u); txpackets += (siz)/32; fseek(in,siz+8, SEEK_CUR); pos += 16+siz; } else if(u == 0xb00a5c11){ fread((void*)&u,4,1,in); unsigned int siz = u & 0xffff; //printf("u 0x%x\n",u); double rxtime = 0.0; fread((void*)&rxtime,8,1,in); char buf[128]; fread((void*)buf,siz,1,in); buf[siz] = 0; //really need to wait for the echo here. //bummish. printf("message: %s\n", buf); //first char: A-P (0-15, corresponds to echo); second space char* b = buf; b+=2; if(strncmp(b, "chan", 4) == 0){ int ii = b[5] - 'A'; if(ii >= 0 && ii < 4){ b += 7; chans[ii] = atoi(b); //printf(" chan %d changed to %d\n", ii, chans[ii]); } } pos += 16+siz; } else { printf("magic number seems off, is 0x%x, %d bytes\n", u,pos); exit(0); } } } printf("finished reading in data file, now writing matlab file.\n"); matvar_t *matvar; matvar = Mat_VarCreate("time",MAT_C_DOUBLE,MAT_T_DOUBLE, 1,&tp,time,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(time); //I wish I had more. matvar = Mat_VarCreate("mstimer",MAT_C_UINT32,MAT_T_UINT32, 1,&tp,mstimer,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(mstimer); int m = tp * 24; matvar = Mat_VarCreate("analog",MAT_C_INT8,MAT_T_INT8, 1,&m,analog,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(analog); matvar = Mat_VarCreate("channel",MAT_C_INT8,MAT_T_INT8, 1,&m,channel,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(channel); matvar = Mat_VarCreate("spike_ts",MAT_C_UINT32,MAT_T_UINT32, 1,&sp,spike_ts,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(spike_ts); matvar = Mat_VarCreate("spike_ch",MAT_C_UINT32,MAT_T_UINT32, 1,&sp,spike_ch,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(spike_ch); matvar = Mat_VarCreate("spike_unit",MAT_C_UINT32,MAT_T_UINT32, 1,&sp,spike_unit,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(spike_unit); Mat_Close(mat); fclose(in); } }
int main (int argc, char *argv[]) { char *str,**str2,*(*qa_records)[4],*line, *oname, *dot, *filename; const char* ext=EXT; int i,j,k,n,n1,n2,cpu_word_size,io_word_size,exo_file,err, num_axes,num_nodes,num_elements,num_blocks, num_side_sets,num_node_sets,num_time_steps, num_qa_lines,num_info_lines,num_global_vars, num_nodal_vars,num_element_vars,num_nodeset_vars, num_sideset_vars, *ids,*iscr,*num_elem_in_block,*junk, *elem_list,*side_list, *nsssides,*nssdfac, *nnsnodes,*nnsdfac, nstr2, has_ss_dfac; float exo_version; double *scr,*x,*y,*z; oname=0; /* process arguments */ for (j=1; j< argc; j++){ if ( strcmp(argv[j],"-t")==0){ /* write text file (*.m) */ del_arg(&argc,argv,j); textfile=1; j--; continue; } if ( strcmp(argv[j],"-o")==0){ /* specify output file name */ del_arg(&argc,argv,j); if ( argv[j] ){ oname=(char*)calloc(strlen(argv[j])+10,sizeof(char)); strcpy(oname,argv[j]); del_arg(&argc,argv,j); printf("output file: %s\n",oname); } else { fprintf(stderr,"Invalid output file specification.\n"); return 2; } j--; continue; } } /* QA Info */ printf("%s: %s, %s\n", qainfo[0], qainfo[2], qainfo[1]); /* usage message*/ if(argc != 2){ printf("%s [options] exodus_file_name.\n",argv[0]); printf(" the exodus_file_name is required (exodusII only).\n"); printf(" Options:\n"); printf(" -t write a text (.m) file rather than a binary .mat\n"); printf(" -o output file name (rather than auto generate)\n"); printf(" ** note **\n"); printf("Binary files are written by default on all platforms with"); printf(" available libraries.\n"); exit(1); } /* open output file */ if ( textfile ) ext=".m"; if ( !oname ){ filename = (char*)malloc( strlen(argv[1])+10); strcpy(filename,argv[1]); dot=strrchr(filename,'.'); if ( dot ) *dot=0; strcat(filename,ext); } else { filename=oname; } if ( textfile ){ m_file = fopen(filename,"w"); if (!m_file ){ fprintf(stderr,"Unable to open %s\n",filename); exit(1); } } else { mat_file = Mat_CreateVer(filename, NULL, MAT_FT_MAT5); if (mat_file == NULL) { fprintf(stderr,"Unable to create matlab file %s\n",filename); exit(1); } } /* word sizes */ cpu_word_size=sizeof(double); io_word_size=0; /* open exodus file */ exo_file=ex_open(argv[1],EX_READ,&cpu_word_size,&io_word_size,&exo_version); if (exo_file < 0){ printf("error opening %s\n",argv[1]); exit(1); } /* print */ fprintf(stderr,"translating %s to %s ...\n",argv[1],filename); /* read database paramters */ line=(char *) calloc ((MAX_LINE_LENGTH+1),sizeof(char)); err = ex_get_init(exo_file,line, &num_axes,&num_nodes,&num_elements,&num_blocks, &num_node_sets,&num_side_sets); num_qa_lines = ex_inquire_int(exo_file,EX_INQ_QA); num_info_lines = ex_inquire_int(exo_file,EX_INQ_INFO); num_time_steps = ex_inquire_int(exo_file,EX_INQ_TIME); err=ex_get_variable_param(exo_file,EX_GLOBAL,&num_global_vars); err=ex_get_variable_param(exo_file,EX_NODAL,&num_nodal_vars); err=ex_get_variable_param(exo_file,EX_ELEM_BLOCK,&num_element_vars); err=ex_get_variable_param(exo_file,EX_NODE_SET,&num_nodeset_vars); err=ex_get_variable_param(exo_file,EX_SIDE_SET,&num_sideset_vars); /* export paramters */ PutInt("naxes", 1, 1,&num_axes); PutInt("nnodes", 1, 1,&num_nodes); PutInt("nelems", 1, 1,&num_elements); PutInt("nblks", 1, 1,&num_blocks); PutInt("nnsets", 1, 1,&num_node_sets); PutInt("nssets", 1, 1,&num_side_sets); PutInt("nsteps", 1, 1,&num_time_steps); PutInt("ngvars", 1, 1,&num_global_vars); PutInt("nnvars", 1, 1,&num_nodal_vars); PutInt("nevars", 1, 1,&num_element_vars); PutInt("nnsvars", 1, 1,&num_nodeset_vars); PutInt("nssvars", 1, 1,&num_sideset_vars); /* allocate -char- scratch space*/ n = num_info_lines; n = (n > num_global_vars) ? n : num_global_vars; n = (n > num_nodal_vars) ? n : num_nodal_vars; n = (n > num_element_vars) ? n : num_element_vars; n = (n > num_blocks) ? n : num_blocks; nstr2 = n; str2= (char **) calloc (n,sizeof(char *)); for (i=0;i<nstr2;i++) str2[i]=(char *) calloc ((MAX_LINE_LENGTH+1),sizeof(char)); str= (char *) calloc ((MAX_LINE_LENGTH+1)*n,sizeof(char)); /* title */ PutStr("Title",line); #if 0 /* QA records */ if (num_qa_lines > 0 ){ qa_records =(char *(*)[4]) calloc (num_qa_lines*4,sizeof(char **)); for (i=0;i<num_qa_lines;i++) for (j=0;j<4;j++) qa_records[i][j]=(char *) calloc ((MAX_STR_LENGTH+1),sizeof(char)); err=ex_get_qa(exo_file,qa_records); str[0]='\0'; for (i=0;i<num_qa_lines;i++){ for (j=0;j<4;j++) sprintf(str+strlen(str),"%s ",qa_records[i][j]); strcat(str,"\n"); } for (i=0;i<num_qa_lines;i++){ for (j=0;j<4;j++) free(qa_records[i][j]); } free(qa_records); } /* information records */ if (num_info_lines > 0 ){ err = ex_get_info(exo_file,str2); str[0]='\0'; for (i=0;i<num_info_lines;i++) sprintf(str+strlen(str),"%s\n",str2[i]); PutStr("info",str); str[0]='\0'; for (i=0;i<num_info_lines;i++) if (strncmp(str2[i],"cavi",4)==0) sprintf(str+strlen(str),"%s\n",str2[i]); PutStr("cvxp",str); } #endif /* nodal coordinates */ x = (double *) calloc(num_nodes,sizeof(double)); y = (double *) calloc(num_nodes,sizeof(double)); if (num_axes == 3) z = (double *) calloc(num_nodes,sizeof(double)); else z = NULL; err = ex_get_coord(exo_file,x,y,z); PutDbl("x0", num_nodes, 1, x); PutDbl("y0", num_nodes, 1, y); free(x); free(y); if (num_axes == 3){ PutDbl("z0",num_nodes,1, z); free(z); } /* side sets */ if(num_side_sets > 0){ ids=(int *) calloc(num_side_sets,sizeof(int)); err = ex_get_ids(exo_file,EX_SIDE_SET,ids); PutInt( "ssids",num_side_sets, 1,ids); nsssides = (int *) calloc(num_side_sets,sizeof(int)); /*dgriffi */ nssdfac = (int *) calloc(num_side_sets,sizeof(int)); /*dgriffi */ for (i=0;i<num_side_sets;i++){ err = ex_get_set_param(exo_file,EX_SIDE_SET, ids[i],&n1,&n2); nsssides[i]=n1; /* dgriffi */ nssdfac[i]=n2; /* dgriffi */ /* * the following provision is from Version 1.6 when there are no * distribution factors in exodus file */ has_ss_dfac = (n2 != 0); if(n2==0 || n1==n2){ printf(" WARNING: Exodus II file does not contain distribution factors.\n"); /* n1=number of faces, n2=number of df */ /* using distribution factors to determine number of nodes in the sideset causes a lot grief since some codes do not output distribution factors if they are all equal to 1. mkbhard: I am using the function call below to figure out the total number of nodes in this sideset. Some redundancy exists, but it works for now */ junk = (int*) calloc(n1,sizeof(int)); err = ex_get_side_set_node_count(exo_file,ids[i],junk); n2=0; /* n2 will be equal to the total number of nodes in the sideset */ for (j=0;j<n1;j++) n2+=junk[j]; free(junk); } iscr = (int *) calloc(n1+n2,sizeof(int)); err = ex_get_side_set_node_list(exo_file,ids[i],iscr,iscr+n1); /* number-of-nodes-per-side list */ sprintf(str,"ssnum%02d",i+1); PutInt(str,n1,1,iscr); /* nodes list */ sprintf(str,"ssnod%02d",i+1); PutInt(str,n2,1,iscr+n1); free(iscr); /* distribution-factors list */ scr = (double *) calloc (n2,sizeof(double)); if (has_ss_dfac) { ex_get_side_set_dist_fact(exo_file,ids[i],scr); } else { for (j=0; j<n2; j++) { scr[j] = 1.0; } } sprintf(str,"ssfac%02d",i+1); PutDbl(str,n2,1,scr); free(scr); /* element and side list for side sets (dgriffi) */ elem_list = (int *) calloc(n1, sizeof(int)); side_list = (int *) calloc(n1, sizeof(int)); err = ex_get_set(exo_file,EX_SIDE_SET,ids[i],elem_list,side_list); sprintf(str,"ssside%02d",i+1); PutInt(str,n1,1,side_list); sprintf(str,"sselem%02d",i+1); PutInt(str,n1,1,elem_list); free(elem_list); free(side_list); } /* Store # sides and # dis. factors per side set (dgriffi) */ PutInt("nsssides",num_side_sets,1,nsssides); PutInt("nssdfac",num_side_sets,1,nssdfac); free(ids); free(nsssides); free(nssdfac); } /* node sets (section by dgriffi) */ if(num_node_sets > 0){ ids=(int *) calloc(num_node_sets,sizeof(int)); err = ex_get_ids(exo_file,EX_NODE_SET, ids); PutInt( "nsids",num_node_sets, 1,ids); nnsnodes = (int *) calloc(num_node_sets,sizeof(int)); nnsdfac = (int *) calloc(num_node_sets,sizeof(int)); for (i=0;i<num_node_sets;i++){ err = ex_get_set_param(exo_file,EX_NODE_SET,ids[i],&n1,&n2); iscr = (int *) calloc(n1,sizeof(int)); err = ex_get_node_set(exo_file,ids[i],iscr); /* nodes list */ sprintf(str,"nsnod%02d",i+1); PutInt(str,n1,1,iscr); free(iscr); /* distribution-factors list */ scr = (double *) calloc (n2,sizeof(double)); ex_get_node_set_dist_fact(exo_file,ids[i],scr); sprintf(str,"nsfac%02d",i+1); PutDbl(str,n2,1,scr); free(scr); nnsnodes[i]=n1; nnsdfac[i]=n2; } /* Store # nodes and # dis. factors per node set */ PutInt("nnsnodes",num_node_sets,1,nnsnodes); PutInt("nnsdfac",num_node_sets,1,nnsdfac); free(ids); free(nnsdfac); free(nnsnodes); } /* element blocks */ ids=(int *) calloc(num_blocks,sizeof(int)); num_elem_in_block=(int *) calloc(num_blocks,sizeof(int)); err = ex_get_ids(exo_file,EX_ELEM_BLOCK,ids); PutInt( "blkids",num_blocks, 1,ids); for (i=0;i<num_blocks;i++) { err = ex_get_elem_block(exo_file,ids[i],str2[i],&n,&n1,&n2); num_elem_in_block[i]=n; iscr = (int *) calloc(n*n1,sizeof(int)); err = ex_get_conn(exo_file,EX_ELEM_BLOCK,ids[i],iscr, NULL, NULL); sprintf(str,"blk%02d",i+1); PutInt(str,n1,n,iscr); free(iscr); } str[0]='\0'; for (i=0;i<num_blocks;i++) sprintf(str+strlen(str),"%s\n",str2[i]); PutStr("blknames",str); /* time values */ if (num_time_steps > 0 ) { scr = (double *) calloc (num_time_steps,sizeof(double)); err= ex_get_all_times (exo_file,scr); PutDbl( "time", num_time_steps, 1,scr); free(scr); } /* global variables */ if (num_global_vars > 0 ) { err = ex_get_variable_names(exo_file,EX_GLOBAL,num_global_vars,str2); str[0]='\0'; for (i=0;i<num_global_vars;i++) sprintf(str+strlen(str),"%s\n",str2[i]); PutStr("gnames",str); scr = (double *) calloc (num_time_steps,sizeof(double)); for (i=0;i<num_global_vars;i++){ sprintf(str,"gvar%02d",i+1); err=ex_get_glob_var_time(exo_file,i+1,1,num_time_steps,scr); PutDbl(str,num_time_steps,1,scr); } free(scr); } /* nodal variables */ if (num_nodal_vars > 0 ) { err = ex_get_variable_names(exo_file,EX_NODAL,num_nodal_vars,str2); str[0]='\0'; for (i=0;i<num_nodal_vars;i++) sprintf(str+strlen(str),"%s\n",str2[i]); PutStr("nnames",str); scr = (double *) calloc (num_nodes*num_time_steps,sizeof(double)); for (i=0;i<num_nodal_vars;i++){ sprintf(str,"nvar%02d",i+1); for (j=0;j<num_time_steps;j++) err=ex_get_nodal_var(exo_file,j+1,i+1,num_nodes, scr+num_nodes*j); PutDbl(str,num_nodes,num_time_steps,scr); } free(scr); } /* element variables */ if (num_element_vars > 0 ) { err = ex_get_variable_names(exo_file,EX_ELEM_BLOCK,num_element_vars,str2); str[0]='\0'; for (i=0;i<num_element_vars;i++) sprintf(str+strlen(str),"%s\n",str2[i]); PutStr("enames",str); /* truth table */ iscr = (int *) calloc(num_element_vars*num_blocks, sizeof(int)); ex_get_elem_var_tab(exo_file,num_blocks,num_element_vars,iscr); for (i=0;i<num_element_vars;i++){ scr = (double *) calloc (num_elements*num_time_steps,sizeof(double)); n=0; sprintf(str,"evar%02d",i+1); for (j=0;j<num_time_steps;j++){ for (k=0;k<num_blocks;k++){ if(iscr[num_element_vars*k+i]==1) ex_get_elem_var(exo_file,j+1,i+1,ids[k],num_elem_in_block[k],scr+n); n=n+num_elem_in_block[k]; } } PutDbl(str,num_elements,num_time_steps,scr); free(scr); } free(iscr); } free(num_elem_in_block); free(ids); /* node and element number maps */ ex_opts(0); /* turn off error reporting. It is not an error to have no map*/ ids = (int *)malloc(num_nodes*sizeof(int)); err = ex_get_node_num_map(exo_file,ids); if ( err==0 ){ PutInt("node_num_map",num_nodes,1,ids); } free(ids); ids = (int *)malloc(num_elements*sizeof(int)); err = ex_get_elem_num_map(exo_file,ids); if ( err==0 ){ PutInt("elem_num_map",num_elements,1,ids); } free(ids); /* close exo file */ ex_close(exo_file); /* close mat file */ if ( textfile ) fclose(m_file); else Mat_Close(mat_file); /* */ fprintf(stderr,"done.\n"); free(filename); free(line); free(str); for (i=0;i<nstr2;i++) free(str2[i]); free(str2); /* exit status */ add_to_log("exo2mat", 0); return(0); }
// load a .mat matlab matrix // will load the first matrix (sparse or dense) in the file // returns 0 on success static int read_mat(char const *const filename, matrix_t *const A) { #ifndef HAVE_MATIO return 1; #else const int LOCAL_DEBUG = 0; mat_t* matfp; matfp = Mat_Open(filename, MAT_ACC_RDONLY); if(matfp == NULL) return 1; // failed to open file matvar_t* t; int more_data = 1; while (more_data) { t = Mat_VarReadNextInfo(matfp); if(t == NULL) { return 2; // no suitable variable found } // TODO decide if this is the one: if(t-> if(1) { more_data = 0; } else { // keep going Mat_VarFree(t); t = NULL; } } { // load the selected variable, including data Mat_Rewind(matfp); matvar_t* tt = Mat_VarRead(matfp, t->name); Mat_VarFree(t); t = tt; if(LOCAL_DEBUG) Mat_VarPrint(tt, 1); } // debug info if(LOCAL_DEBUG && t->name != NULL) printf("%s: loaded variable %s\n", filename, t->name); // checks and data handling int ret = 0; if(t->rank > 2 || t->rank <= 0) { // number of dimensions ret = 2; } else if(t->data_type != MAT_T_DOUBLE) { if(LOCAL_DEBUG) printf("data_type=%d\n",t->data_type); ret = 3; } else if(t->isComplex) { ret = 10; // TODO can't handle complex matrices yet } else if(t->isLogical) { ret = 11; // TODO can't handle logicals yet } else { if(t->rank == 1) { A->m = t->dims[0]; // rows A->n = 1; // cols } else { A->m = t->dims[0]; // rows A->n = t->dims[1]; // cols } A->sym = SM_UNSYMMETRIC; //if(t->data_type == MAT_T_DOUBLE) { A->data_type = REAL_DOUBLE; //} // TODO complex, single precision, various sized integers if(t->class_type == MAT_C_SPARSE) { // t.data = sparse_t in CSC format // Note that Matlab will save('-v4'...) a sparse matrix // to version 4 format without complaint but it appears // to be gibberish as far as MatIO is concerned sparse_t* st = t->data; A->nz = st->ndata; //st->nzmax has the actual size of the allocated st->data A->format = SM_CSC; // transfer the data pointer into our strucut // TODO check for negative values in ir/jc before throwing away their signs A->ii = (unsigned int*) st->ir; st->ir = NULL; A->jj = (unsigned int*) st->jc; st->jc = NULL; A->dd = st->data; st->data = NULL; } else if(t->class_type == MAT_C_DOUBLE) { A->nz = A->m * A->n; A->format = DCOL; // transfer the data pointer into our struct A->dd = t->data; t->data = NULL; } else { ret = 4; // unknown class of data structure } } // DEBUG if(LOCAL_DEBUG && validate_matrix(A) != 0) { ret = 50; fprintf(stderr, "problem loading .mat matrix file\n"); printf_matrix(" ", A); } // sanity checks // t.dims[] is don't-care // t.isGlobal is don't-care Mat_Close(matfp); Mat_VarFree(t); return ret; // success? #endif }
void SimpleVector<Scalar>::export_to_file(const char *filename, const char *var_name, MatrixExportFormat fmt, char* number_format) { if (!v) throw Exceptions::MethodNotOverridenException("Vector<Scalar>::export_to_file"); switch (fmt) { case EXPORT_FORMAT_MATRIX_MARKET: { FILE* file = fopen(filename, "w"); if (!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); if (Hermes::Helpers::TypeIsReal<Scalar>::value) fprintf(file, "%%%%MatrixMarket matrix coordinate real general\n"); else fprintf(file, "%%%%MatrixMarket matrix coordinate complex general\n"); fprintf(file, "%d 1 %d\n", this->size, this->size); for (unsigned int j = 0; j < this->size; j++) { Hermes::Helpers::fprint_coordinate_num(file, j + 1, 1, v[j], number_format); fprintf(file, "\n"); } fclose(file); } break; case EXPORT_FORMAT_MATLAB_MATIO: { #ifdef WITH_MATIO size_t dims[2]; dims[0] = this->size; dims[1] = 1; mat_t *mat = Mat_CreateVer(filename, "", MAT_FT_MAT5); matvar_t *matvar; // For complex. double* v_re = nullptr; double* v_im = nullptr; void* data; if (Hermes::Helpers::TypeIsReal<Scalar>::value) { data = v; matvar = Mat_VarCreate(var_name, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, data, MAT_F_DONT_COPY_DATA); } else { v_re = malloc_with_check<SimpleVector<Scalar>, double>(this->size, this); v_im = malloc_with_check<SimpleVector<Scalar>, double>(this->size, this); struct mat_complex_split_t z = { v_re, v_im }; for (int i = 0; i < this->size; i++) { v_re[i] = ((std::complex<double>)(this->v[i])).real(); v_im[i] = ((std::complex<double>)(this->v[i])).imag(); data = &z; } matvar = Mat_VarCreate(var_name, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, data, MAT_F_DONT_COPY_DATA | MAT_F_COMPLEX); } if (matvar) { Mat_VarWrite(mat, matvar, MAT_COMPRESSION_ZLIB); Mat_VarFree(matvar); } free_with_check(v_re); free_with_check(v_im); Mat_Close(mat); if (!matvar) throw Exceptions::IOException(Exceptions::IOException::Write, filename); #else throw Exceptions::Exception("MATIO not included."); #endif } break; case EXPORT_FORMAT_PLAIN_ASCII: case EXPORT_FORMAT_MATLAB_SIMPLE: { FILE* file = fopen(filename, "w"); if (!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); for (unsigned int i = 0; i < this->size; i++) { Hermes::Helpers::fprint_num(file, v[i], number_format); fprintf(file, "\n"); } fclose(file); } break; #ifdef WITH_BSON case EXPORT_FORMAT_BSON: { // Init bson bson bw; bson_init(&bw); // Matrix size. bson_append_int(&bw, "size", this->size); bson_append_start_array(&bw, "v"); for (unsigned int i = 0; i < this->size; i++) bson_append_double(&bw, "v_i", real(this->v[i])); bson_append_finish_array(&bw); if (!Hermes::Helpers::TypeIsReal<Scalar>::value) { bson_append_start_array(&bw, "v-imag"); for (unsigned int i = 0; i < this->size; i++) bson_append_double(&bw, "v_i", imag(this->v[i])); bson_append_finish_array(&bw); } // Done. bson_finish(&bw); // Write to disk. FILE *fpw; fpw = fopen(filename, "wb"); const char *dataw = (const char *)bson_data(&bw); fwrite(dataw, bson_size(&bw), 1, fpw); fclose(fpw); bson_destroy(&bw); } #endif } }
void SimpleVector<Scalar>::import_from_file(const char *filename, const char *var_name, MatrixExportFormat fmt) { switch (fmt) { case EXPORT_FORMAT_PLAIN_ASCII: { std::vector<Scalar> data; std::ifstream input(filename); if (input.bad()) throw Exceptions::IOException(Exceptions::IOException::Read, filename); std::string lineData; while (getline(input, lineData)) { Scalar d; std::stringstream lineStream(lineData); lineStream >> d; data.push_back(d); } this->alloc(data.size()); memcpy(this->v, &data[0], sizeof(Scalar)*data.size()); } break; case EXPORT_FORMAT_MATLAB_MATIO: #ifdef WITH_MATIO mat_t *matfp; matvar_t *matvar; matfp = Mat_Open(filename, MAT_ACC_RDONLY); if (!matfp) { throw Exceptions::IOException(Exceptions::IOException::Read, filename); return; } matvar = Mat_VarRead(matfp, var_name); if (matvar) { this->alloc(matvar->dims[0]); if (Hermes::Helpers::TypeIsReal<Scalar>::value) memcpy(this->v, matvar->data, sizeof(Scalar)*this->size); else { std::complex<double>* complex_data = malloc_with_check<SimpleVector<Scalar>, std::complex<double> >(this->size, this); double* real_array = (double*)((mat_complex_split_t*)matvar->data)->Re; double* imag_array = (double*)((mat_complex_split_t*)matvar->data)->Im; for (int i = 0; i < this->size; i++) complex_data[i] = std::complex<double>(real_array[i], imag_array[i]); memcpy(this->v, complex_data, sizeof(Scalar)*this->size); free_with_check(complex_data); } } Mat_Close(matfp); if (!matvar) throw Exceptions::IOException(Exceptions::IOException::Read, filename); #else throw Exceptions::Exception("MATIO not included."); #endif break; case EXPORT_FORMAT_MATRIX_MARKET: throw Hermes::Exceptions::MethodNotImplementedException("SimpleVector<Scalar>::import_from_file - Matrix Market"); break; #ifdef WITH_BSON case EXPORT_FORMAT_BSON: { FILE *fpr; fpr = fopen(filename, "rb"); // file size: fseek(fpr, 0, SEEK_END); int size = ftell(fpr); rewind(fpr); // allocate memory to contain the whole file: char *datar = malloc_with_check<char>(size); fread(datar, size, 1, fpr); fclose(fpr); bson br; bson_init_finished_data(&br, datar, 0); bson_iterator it; bson sub; bson_find(&it, &br, "size"); this->size = bson_iterator_int(&it); this->v = malloc_with_check<SimpleVector<Scalar>, Scalar>(this->size, this); bson_iterator it_coeffs; bson_find(&it_coeffs, &br, "v"); bson_iterator_subobject_init(&it_coeffs, &sub, 0); bson_iterator_init(&it, &sub); int index_coeff = 0; while (bson_iterator_next(&it)) this->v[index_coeff++] = bson_iterator_double(&it); if (!Hermes::Helpers::TypeIsReal<Scalar>::value) { bson_find(&it_coeffs, &br, "v-imag"); bson_iterator_subobject_init(&it_coeffs, &sub, 0); bson_iterator_init(&it, &sub); index_coeff = 0; while (bson_iterator_next(&it)) ((std::complex<double>)this->v[index_coeff++]).imag(bson_iterator_double(&it)); } bson_destroy(&br); free_with_check(datar); } break; #endif } }
void SimpleVector<Scalar>::import_from_file(const char *filename, const char *var_name, MatrixExportFormat fmt) { switch (fmt) { case EXPORT_FORMAT_PLAIN_ASCII: { std::vector<Scalar> data; std::ifstream input (filename); if(input.bad()) throw Exceptions::IOException(Exceptions::IOException::Read, filename); std::string lineData; while(getline(input, lineData)) { Scalar d; std::stringstream lineStream(lineData); lineStream >> d; data.push_back(d); } this->alloc(data.size()); memcpy(this->v, &data[0], sizeof(Scalar)*data.size()); } break; case EXPORT_FORMAT_MATLAB_MATIO: #ifdef WITH_MATIO mat_t *matfp; matvar_t *matvar; matfp = Mat_Open(filename,MAT_ACC_RDONLY); if (!matfp ) { throw Exceptions::IOException(Exceptions::IOException::Read, filename); return; } matvar = Mat_VarRead(matfp, var_name); if (matvar) { this->alloc(matvar->dims[0]); if(Hermes::Helpers::TypeIsReal<Scalar>::value) memcpy(this->v, matvar->data, sizeof(Scalar)*this->size); else { std::complex<double>* complex_data = new std::complex<double>[this->size]; double* real_array = (double*)((mat_complex_split_t*)matvar->data)->Re; double* imag_array = (double*)((mat_complex_split_t*)matvar->data)->Im; for(int i = 0; i < this->size; i++) complex_data[i] = std::complex<double>(real_array[i], imag_array[i]); memcpy(this->v, complex_data, sizeof(Scalar)*this->size); delete [] complex_data; } } Mat_Close(matfp); if(!matvar) throw Exceptions::IOException(Exceptions::IOException::Read, filename); #else throw Exceptions::Exception("MATIO not included."); #endif break; case EXPORT_FORMAT_MATRIX_MARKET: throw Hermes::Exceptions::MethodNotImplementedException("SimpleVector<Scalar>::import_from_file - Matrix Market"); } }
void SimpleVector<Scalar>::export_to_file(const char *filename, const char *var_name, MatrixExportFormat fmt, char* number_format) { if(!v) throw Exceptions::MethodNotOverridenException("Vector<Scalar>::export_to_file"); switch (fmt) { case EXPORT_FORMAT_MATRIX_MARKET: { FILE* file = fopen(filename, "w"); if(!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); if(Hermes::Helpers::TypeIsReal<Scalar>::value) fprintf(file, "%%%%Matrix<Scalar>Market matrix coordinate real\n"); else fprintf(file, "%%%%Matrix<Scalar>Market matrix coordinate complex\n"); fprintf(file, "%d 1 %d\n", this->size, this->size); for (unsigned int j = 0; j < this->size; j++) { Hermes::Helpers::fprint_coordinate_num(file, j + 1, 1, v[j], number_format); fprintf(file, "\n"); } fclose(file); } break; case EXPORT_FORMAT_MATLAB_MATIO: { #ifdef WITH_MATIO size_t dims[2]; dims[0] = this->size; dims[1] = 1; mat_t *mat = Mat_CreateVer(filename, "", MAT_FT_MAT5); matvar_t *matvar; // For complex. double* v_re = nullptr; double* v_im = nullptr; void* data; if(Hermes::Helpers::TypeIsReal<Scalar>::value) { data = v; matvar = Mat_VarCreate(var_name, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, data, MAT_F_DONT_COPY_DATA); } else { v_re = new double[this->size]; v_im = new double[this->size]; struct mat_complex_split_t z = {v_re, v_im}; for(int i = 0; i < this->size; i++) { v_re[i] = ((std::complex<double>)(this->v[i])).real(); v_im[i] = ((std::complex<double>)(this->v[i])).imag(); data = &z; } matvar = Mat_VarCreate(var_name, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, data, MAT_F_DONT_COPY_DATA | MAT_F_COMPLEX); } if (matvar) { Mat_VarWrite(mat, matvar, MAT_COMPRESSION_ZLIB); Mat_VarFree(matvar); } if(v_re) delete [] v_re; if(v_im) delete [] v_im; Mat_Close(mat); if(!matvar) throw Exceptions::IOException(Exceptions::IOException::Write, filename); #else throw Exceptions::Exception("MATIO not included."); #endif } break; case EXPORT_FORMAT_PLAIN_ASCII: { FILE* file = fopen(filename, "w"); if(!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); for (unsigned int i = 0; i < this->size; i++) { Hermes::Helpers::fprint_num(file, v[i], number_format); fprintf(file, "\n"); } fclose(file); } } }
void CSMatrix<Scalar>::export_to_file(const char *filename, const char *var_name, MatrixExportFormat fmt, char* number_format, bool invert_storage) { switch (fmt) { case EXPORT_FORMAT_MATRIX_MARKET: { FILE* file = fopen(filename, "w"); if(!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); if(Hermes::Helpers::TypeIsReal<Scalar>::value) fprintf(file, "%%%%Matrix<Scalar>Market matrix coordinate real\n"); else fprintf(file, "%%%%Matrix<Scalar>Market matrix coordinate complex\n"); fprintf(file, "%d %d %d\n", this->size, this->size, this->nnz); if(invert_storage) this->switch_orientation(); for (unsigned int j = 0; j < this->size; j++) { for (int i = Ap[j]; i < Ap[j + 1]; i++) { Hermes::Helpers::fprint_coordinate_num(file, i_coordinate(Ai[i] + 1, j + 1, invert_storage), j_coordinate(Ai[i] + 1, j + 1, invert_storage), Ax[i], number_format); fprintf(file, "\n"); } } if(invert_storage) this->switch_orientation(); fclose(file); } break; case EXPORT_FORMAT_MATLAB_MATIO: { #ifdef WITH_MATIO mat_sparse_t sparse; sparse.nzmax = this->nnz; if(invert_storage) this->switch_orientation(); sparse.nir = this->nnz; sparse.ir = Ai; sparse.njc = this->size + 1; sparse.jc = (int *) Ap; sparse.ndata = this->nnz; size_t dims[2]; dims[0] = this->size; dims[1] = this->size; mat_t *mat = Mat_CreateVer(filename, "", MAT_FT_MAT5); matvar_t *matvar; // For complex. No allocation here. double* Ax_re = nullptr; double* Ax_im = nullptr; // For real. if(Hermes::Helpers::TypeIsReal<Scalar>::value) { sparse.data = Ax; matvar = Mat_VarCreate(var_name, MAT_C_SPARSE, MAT_T_DOUBLE, 2, dims, &sparse, MAT_F_DONT_COPY_DATA); } else { // For complex. Ax_re = new double[this->nnz]; Ax_im = new double[this->nnz]; struct mat_complex_split_t z = {Ax_re, Ax_im}; for(int i = 0; i < this->nnz; i++) { Ax_re[i] = ((std::complex<double>)(this->Ax[i])).real(); Ax_im[i] = ((std::complex<double>)(this->Ax[i])).imag(); sparse.data = &z; } matvar = Mat_VarCreate(var_name, MAT_C_SPARSE, MAT_T_DOUBLE, 2, dims, &sparse, MAT_F_DONT_COPY_DATA | MAT_F_COMPLEX); } if (matvar) { Mat_VarWrite(mat, matvar, MAT_COMPRESSION_ZLIB); Mat_VarFree(matvar); } if(invert_storage) this->switch_orientation(); if(Ax_re) delete [] Ax_re; if(Ax_im) delete [] Ax_im; Mat_Close(mat); if(!matvar) throw Exceptions::IOException(Exceptions::IOException::Write, filename); #endif } break; case EXPORT_FORMAT_PLAIN_ASCII: { FILE* file = fopen(filename, "w"); if(!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); if(invert_storage) this->switch_orientation(); for (unsigned int j = 0; j < this->size; j++) { for (int i = Ap[j]; i < Ap[j + 1]; i++) { Helpers::fprint_coordinate_num(file, i_coordinate(Ai[i], j, invert_storage), j_coordinate(Ai[i], j, invert_storage), Ax[i], number_format); fprintf(file, "\n"); } } if(invert_storage) this->switch_orientation(); fclose(file); } } }
void CSMatrix<Scalar>::export_to_file(const char *filename, const char *var_name, MatrixExportFormat fmt, char* number_format, bool invert_storage) { switch (fmt) { case EXPORT_FORMAT_MATRIX_MARKET: { FILE* file = fopen(filename, "w"); if (!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); if (Hermes::Helpers::TypeIsReal<Scalar>::value) fprintf(file, "%%%%MatrixMarket matrix coordinate real general\n"); else fprintf(file, "%%%%MatrixMarket matrix coordinate complex general\n"); fprintf(file, "%d %d %d\n", this->size, this->size, this->nnz); if (invert_storage) this->switch_orientation(); for (unsigned int j = 0; j < this->size; j++) { for (int i = Ap[j]; i < Ap[j + 1]; i++) { Hermes::Helpers::fprint_coordinate_num(file, i_coordinate(Ai[i] + 1, j + 1, invert_storage), j_coordinate(Ai[i] + 1, j + 1, invert_storage), Ax[i], number_format); fprintf(file, "\n"); } } if (invert_storage) this->switch_orientation(); fclose(file); } break; case EXPORT_FORMAT_MATLAB_MATIO: { #ifdef WITH_MATIO mat_sparse_t sparse; sparse.nzmax = this->nnz; if (invert_storage) this->switch_orientation(); sparse.nir = this->nnz; sparse.ir = Ai; sparse.njc = this->size + 1; sparse.jc = (int *)Ap; sparse.ndata = this->nnz; size_t dims[2]; dims[0] = this->size; dims[1] = this->size; mat_t *mat = Mat_CreateVer(filename, "", MAT_FT_MAT5); matvar_t *matvar; // For complex. No allocation here. double* Ax_re = nullptr; double* Ax_im = nullptr; // For real. if (Hermes::Helpers::TypeIsReal<Scalar>::value) { sparse.data = Ax; matvar = Mat_VarCreate(var_name, MAT_C_SPARSE, MAT_T_DOUBLE, 2, dims, &sparse, MAT_F_DONT_COPY_DATA); } else { // For complex. Ax_re = malloc_with_check<CSMatrix<Scalar>, double>(this->nnz, this); Ax_im = malloc_with_check<CSMatrix<Scalar>, double>(this->nnz, this); struct mat_complex_split_t z = { Ax_re, Ax_im }; for (int i = 0; i < this->nnz; i++) { Ax_re[i] = ((std::complex<double>)(this->Ax[i])).real(); Ax_im[i] = ((std::complex<double>)(this->Ax[i])).imag(); sparse.data = &z; } matvar = Mat_VarCreate(var_name, MAT_C_SPARSE, MAT_T_DOUBLE, 2, dims, &sparse, MAT_F_DONT_COPY_DATA | MAT_F_COMPLEX); } if (matvar) { Mat_VarWrite(mat, matvar, MAT_COMPRESSION_ZLIB); Mat_VarFree(matvar); } if (invert_storage) this->switch_orientation(); free_with_check(Ax_re); free_with_check(Ax_im); Mat_Close(mat); if (!matvar) throw Exceptions::IOException(Exceptions::IOException::Write, filename); #endif } break; case EXPORT_FORMAT_PLAIN_ASCII: { FILE* file = fopen(filename, "w"); if (!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); if (invert_storage) this->switch_orientation(); for (unsigned int j = 0; j < this->size; j++) { for (int i = Ap[j]; i < Ap[j + 1]; i++) { Helpers::fprint_coordinate_num(file, i_coordinate(Ai[i], j, invert_storage), j_coordinate(Ai[i], j, invert_storage), Ax[i], number_format); fprintf(file, "\n"); } } if (invert_storage) this->switch_orientation(); fclose(file); } break; #ifdef WITH_BSON case EXPORT_FORMAT_BSON: { // Init bson bson bw; bson_init(&bw); // Matrix size. bson_append_int(&bw, "size", this->size); // Nonzeros. bson_append_int(&bw, "nnz", this->nnz); if (invert_storage) this->switch_orientation(); bson_append_start_array(&bw, "Ap"); for (unsigned int i = 0; i < this->size; i++) bson_append_int(&bw, "p", this->Ap[i]); bson_append_finish_array(&bw); bson_append_start_array(&bw, "Ai"); for (unsigned int i = 0; i < this->nnz; i++) bson_append_int(&bw, "i", this->Ai[i]); bson_append_finish_array(&bw); bson_append_start_array(&bw, "Ax"); for (unsigned int i = 0; i < this->nnz; i++) bson_append_double(&bw, "x", real(this->Ax[i])); bson_append_finish_array(&bw); if (!Hermes::Helpers::TypeIsReal<Scalar>::value) { bson_append_start_array(&bw, "Ax-imag"); for (unsigned int i = 0; i < this->nnz; i++) bson_append_double(&bw, "x-i", imag(this->Ax[i])); bson_append_finish_array(&bw); } bson_append_finish_array(&bw); if (invert_storage) this->switch_orientation(); // Done. bson_finish(&bw); // Write to disk. FILE *fpw; fpw = fopen(filename, "wb"); const char *dataw = (const char *)bson_data(&bw); fwrite(dataw, bson_size(&bw), 1, fpw); fclose(fpw); bson_destroy(&bw); } break; #endif } }
int main(int argc, char **argv) { char *mdf_filename = NULL; char *mat_filename = NULL; const mdf_t *mdf; filter_t *filter; char *filter_filename = NULL; char *program_name = argv[0]; /* parse arguments */ while (1) { static struct option long_options[] = { /* These options set a flag. */ {"verbose", no_argument, &verbose_level, 1}, {"debug", no_argument, &verbose_level, 2}, {"deep", no_argument, &verbose_level, 3}, {"brief", no_argument, &verbose_level, 0}, {"v5", no_argument, &mat_file_ver, (int)MAT_FT_MAT5}, {"v73", no_argument, &mat_file_ver, (int)MAT_FT_MAT73}, {"compress",no_argument, NULL, 'z'}, /* These options don't set a flag. We distinguish them by their indices. */ {"filter", required_argument, 0, (int)'f'}, {"help", no_argument, NULL, (int)'h'}, {0, 0, 0, 0} }; /* getopt_long stores the option index here. */ int option_index = 0; int c; c = getopt_long (argc, argv, "a:b:d:f:hm:t:vz", long_options, &option_index); /* Detect the end of the options. */ if (c == -1) break; switch (c) { case 0: break; case 'f': filter_filename = optarg; break; case 'h': help(program_name); exit(EXIT_SUCCESS); break; case 'v': verbose_level = 1; break; case 'd': verbose_level = 2; break; case 'z': mdftomat.compress = MAT_COMPRESSION_ZLIB; break; case '?': /* getopt_long already printed an error message. */ usage_error(program_name); break; default: fprintf(stderr, "error: unknown option %c\n", c); usage_error(program_name); } } /* check structure packing */ assert(offsetof(cn_block_t,link_asam_mcd_name) == 218); /* input files */ if (optind == argc - 2) { mdf_filename = argv[optind++]; mat_filename = argv[optind++]; } else { fprintf(stderr, "error: wrong number of arguments\n"); usage_error(program_name); return 1; } /* print banner */ if(verbose_level >= 1) { fprintf(stderr, "%s (%s, %s, cantools " PACKAGE_VERSION ")\n", program_name, __DATE__, __TIME__); } /* connect to mdf file */ mdf = mdf_attach(mdf_filename, verbose_level); if(mdf == NULL) { return 1; } /* create mat file */ mdftomat.mat = Mat_CreateVer(mat_filename, NULL, (enum mat_ft)mat_file_ver); if(mdftomat.mat == NULL) { fprintf(stderr,"can't write to mat file %s\n",mat_filename); return 1; } /* read filter */ if(filter_filename != NULL) { filter = mdf_filter_create(filter_filename); if(filter == NULL) { return 1; } } else { filter = NULL; } /* process MDF file */ if(verbose_level >= 1) { fprintf(stderr, "converting %s to %sfile %s\n", mdf_filename, (mdftomat.compress == MAT_COMPRESSION_ZLIB)?"compressed ":"", mat_filename); } mdfProcess(mdf, &mdftomat, filter); /* free filter */ filter_free(filter); /* detach from mdf file */ mdf_detach(mdf); /* close mat file */ Mat_Close(mdftomat.mat); /* say goodbye */ if(verbose_level >= 1) { puts("done."); } return 0; }
void CSMatrix<Scalar>::import_from_file(const char *filename, const char *var_name, MatrixExportFormat fmt, bool invert_storage) { this->free(); switch (fmt) { case EXPORT_FORMAT_MATRIX_MARKET: throw Exceptions::MethodNotOverridenException("CSMatrix<Scalar>::import_from_file - Matrix Market"); break; case EXPORT_FORMAT_MATLAB_MATIO: { #ifdef WITH_MATIO mat_t *matfp; matvar_t *matvar; matfp = Mat_Open(filename, MAT_ACC_RDONLY); if (!matfp) throw Exceptions::IOException(Exceptions::IOException::Read, filename); matvar = Mat_VarRead(matfp, var_name); if (matvar) { mat_sparse_t *sparse = (mat_sparse_t *)matvar->data; this->nnz = sparse->nir; this->Ax = malloc_with_check<CSMatrix<Scalar>, Scalar>(this->nnz, this); this->Ai = malloc_with_check<CSMatrix<Scalar>, int>(this->nnz, this); this->size = sparse->njc; this->Ap = malloc_with_check<CSMatrix<Scalar>, int>(this->size + 1, this); void* data = nullptr; if (Hermes::Helpers::TypeIsReal<Scalar>::value) data = sparse->data; else { std::complex<double>* complex_data = malloc_with_check<CSMatrix<Scalar>, std::complex<double> >(this->nnz, this); double* real_array = (double*)((mat_complex_split_t*)sparse->data)->Re; double* imag_array = (double*)((mat_complex_split_t*)sparse->data)->Im; for (int i = 0; i < this->nnz; i++) complex_data[i] = std::complex<double>(real_array[i], imag_array[i]); data = (void*)complex_data; } memcpy(this->Ax, data, this->nnz * sizeof(Scalar)); if (!Hermes::Helpers::TypeIsReal<Scalar>::value) free_with_check(data); memcpy(this->Ap, sparse->jc, this->size * sizeof(int)); this->Ap[this->size] = this->nnz; memcpy(this->Ai, sparse->ir, this->nnz * sizeof(int)); if (invert_storage) this->switch_orientation(); } Mat_Close(matfp); if (!matvar) throw Exceptions::IOException(Exceptions::IOException::Read, filename); #else throw Exceptions::Exception("MATIO not included."); #endif } break; case EXPORT_FORMAT_PLAIN_ASCII: throw Exceptions::MethodNotOverridenException("CSMatrix<Scalar>::import_from_file - Simple format"); #ifdef WITH_BSON case EXPORT_FORMAT_BSON: { FILE *fpr; fpr = fopen(filename, "rb"); // file size: fseek(fpr, 0, SEEK_END); int size = ftell(fpr); rewind(fpr); // allocate memory to contain the whole file: char *datar = malloc_with_check<char>(size); fread(datar, size, 1, fpr); fclose(fpr); bson br; bson_init_finished_data(&br, datar, 0); bson_iterator it; bson sub; bson_find(&it, &br, "size"); this->size = bson_iterator_int(&it); bson_find(&it, &br, "nnz"); this->nnz = bson_iterator_int(&it); this->Ap = malloc_with_check<CSMatrix<Scalar>, int>(this->size + 1, this); this->Ai = malloc_with_check<CSMatrix<Scalar>, int>(nnz, this); this->Ax = malloc_with_check<CSMatrix<Scalar>, Scalar>(nnz, this); // coeffs bson_iterator it_coeffs; bson_find(&it_coeffs, &br, "Ap"); bson_iterator_subobject_init(&it_coeffs, &sub, 0); bson_iterator_init(&it, &sub); int index_coeff = 0; while (bson_iterator_next(&it)) this->Ap[index_coeff++] = bson_iterator_int(&it); this->Ap[this->size] = this->nnz; bson_find(&it_coeffs, &br, "Ai"); bson_iterator_subobject_init(&it_coeffs, &sub, 0); bson_iterator_init(&it, &sub); index_coeff = 0; while (bson_iterator_next(&it)) this->Ai[index_coeff++] = bson_iterator_int(&it); bson_find(&it_coeffs, &br, "Ax"); bson_iterator_subobject_init(&it_coeffs, &sub, 0); bson_iterator_init(&it, &sub); index_coeff = 0; while (bson_iterator_next(&it)) this->Ax[index_coeff++] = bson_iterator_double(&it); if (!Hermes::Helpers::TypeIsReal<Scalar>::value) { bson_find(&it_coeffs, &br, "Ax-imag"); bson_iterator_subobject_init(&it_coeffs, &sub, 0); bson_iterator_init(&it, &sub); index_coeff = 0; while (bson_iterator_next(&it)) ((std::complex<double>)this->Ax[index_coeff++]).imag(bson_iterator_double(&it)); } if (invert_storage) this->switch_orientation(); bson_destroy(&br); free_with_check(datar); } #endif break; } }
void Job::run(){ if (Print) cout << endl << "------ new run ------ iRip==" << iRip << endl << endl; // int iTr=0,iTs=0,iVar,iV,iFRip, i,ii, trsz=ds.pr->TrSzD, tssz=ds.pr->TsSzD, valdim=ds.LabelValSelSize; double acc[trsz][tssz][FRip], mse[trsz][tssz][FRip], scc[trsz][tssz][FRip], featNum[FeatSelSize][FRip], *res,trends[valdim][trsz][FRip],actualLabel[valdim],ValidTrend[valdim]; matvar_t *varnameC; // for (iVar=0; iVar<LabelSelSize; ++iVar){ iV=LabelSelIdx[iVar]; // questa e` la variabile che vogliamo decodificare // -------------- cambio il nome del file in modo da coincidere con la variabile -------------------------------------- string resFile_=resFile,VARNAME; // cosi` lo scope e` locale in questo ciclo varnameC = Mat_VarGetCell(VARIABLEs,iV); // recupero il nome di questa variabile VARNAME=(const char*)varnameC->data; // segnalo dove sono a video if (Print) cout << endl << "------ iV=" << VARNAME << endl << endl; // resFile_+=VARNAME; resFile_+="-"; // riporto quale variabile sto esaminando nel filename resFile_+="nF_"; resFile_+=to_string(FeatSelSize); resFile_+="-"; // e quante features resFile_+="res.mat"; // aggiungo l'estensione // elimino gli spazi resFile_.erase(remove_if(resFile_.begin(), resFile_.end(), [](char x){return isspace(x);}), resFile_.end()); // -------------------------------------------------------------------------------------------------------------------- // // ---------------------------- recupero l'andamento della label sul validation set ---------------------------------- for (ii=0; ii<valdim; ++ii){ i=ds.label_valid_selection[ii]; actualLabel[ii]=labels[LabelSize[0]*iV+i]; // prendo l'i-esimo indice del del validation set della variabile iV // LabelSize[0] e` il numero totale delle istanze } // --------------------------------------------------------------------------------------------------------------------- // for (iTr=0; iTr<trsz; ++iTr){ ds.assegnoTrainingSet(iTr); for (iFRip=0; iFRip<FRip; ++iFRip){ if (Print) cout << endl << "------ iTr%=" << (double)iTr/trsz << endl << "------ iFRip%=" << (double)iFRip/FRip << endl << endl; UpdateFeatureSelection(); // cambio, se devo, la selezione delle features // // ----------------------------------------- recupero gli indici delle features --------------------------------------- for (i=0; i<FeatSelSize; ++i) // recupero gli indici delle feature che ho usato featNum[i][iFRip]=(double)(feature_sel[i]+1); // per metterla nel ws di matio // aggiungo 1.0 per come funziona l'indicizzazione su matlab // --------------------------------------------------------------------------------------------------------------------- // // per debug if (0){ cout << endl << "feat idx" << endl; for (int i=0; i<FeatSelSize; ++i) cout << " " << feature_sel[i]; cout << endl; } assegnato_svm=false; // devo riaddestrare per ogni Training Set o per ogni sottocampionamento delle features TrainingFromAssignedProblem(iV); // addestro con lo stesso Training Set ma (forse) diverse Features predictValidationSet(ValidTrend,iV); // Test sul Validation Set // ------------------------------- recupero i trends sul Validation Set ----------------------------------------- for (ii=0; ii<valdim; ++ii) trends[ii][iTr][iFRip]=ValidTrend[ii]; // -------------------------------------------------------------------------------------------------------------- // for (iTs=0; iTs<tssz; ++iTs){ ds.assegnoTestSet(iTs); predictTestSet(iV); // recupero le performance del modello res = (double *)((matvar_t *)RES[1])->data; acc[iTr][iTs][iFRip]=res[0]; mse[iTr][iTs][iFRip]=res[1]; scc[iTr][iTs][iFRip]=res[2]; } } } // -------------- salvo un file per ogni variabile | setto il workspace da salvare -------------------------------------- int WsSize=12; matvar_t *workspace[WsSize]; size_t dims_3[3], dims_2[2], dims_1[1]; dims_3[2]=trsz; dims_3[1]=tssz; dims_3[0]=FRip; dims_2[1]=FeatSelSize; dims_2[0]=FRip; dims_1[0]=1; workspace[0] = Mat_VarCreate("acc",MAT_C_DOUBLE,MAT_T_DOUBLE,3,dims_3,acc,0); workspace[1] = Mat_VarCreate("mse",MAT_C_DOUBLE,MAT_T_DOUBLE,3,dims_3,mse,0); workspace[2] = Mat_VarCreate("scc",MAT_C_DOUBLE,MAT_T_DOUBLE,3,dims_3,scc,0); workspace[3] = Mat_VarCreate("featIdx",MAT_C_DOUBLE,MAT_T_DOUBLE,2,dims_2,featNum,0); dims_2[1]=valdim; dims_2[0]=1; workspace[4] = Mat_VarCreate("actualLabel",MAT_C_DOUBLE,MAT_T_DOUBLE,2,dims_2,actualLabel,0); dims_3[2]=valdim; dims_3[1]=trsz; dims_3[0]=FRip; workspace[5] = Mat_VarCreate("trends",MAT_C_DOUBLE,MAT_T_DOUBLE,3,dims_3,trends,0); double FRip_ws[1], trsz_ws[1], tssz_ws[1], FeatSelSize_ws[1], validSz_ws[1]; FRip_ws[0]=FRip; trsz_ws[0]=trsz; tssz_ws[0]=tssz; FeatSelSize_ws[0]=FeatSelSize; validSz_ws[0]=valdim; workspace[6] = Mat_VarCreate("FeatSelectionRip",MAT_C_DOUBLE,MAT_T_DOUBLE,1,dims_1,FRip_ws,0); workspace[7] = Mat_VarCreate("NumFeatures",MAT_C_DOUBLE,MAT_T_DOUBLE,1,dims_1,FeatSelSize_ws,0); workspace[8] = Mat_VarCreate("TrSz",MAT_C_DOUBLE,MAT_T_DOUBLE,1,dims_1,trsz_ws,0); workspace[9] = Mat_VarCreate("TsSz",MAT_C_DOUBLE,MAT_T_DOUBLE,1,dims_1,tssz_ws,0); workspace[10] = Mat_VarCreate("ValidationSetSize",MAT_C_DOUBLE,MAT_T_DOUBLE,1,dims_1,validSz_ws,0); string help ="CONTENUTO DEL MATFILE:\n"; help+="{acc,mse,scc}\n"; help+="\tdimensione RxTsxTr\n"; help+="\t(accuratezza,mean squared error ed r2\n\toutput di libsvm)\n"; help+="featIdx\n"; help+="\tdimensione RxN\n"; help+="\t(indice delle features usate per addestrare\n\t il modello ad ogni ricampionamento)\n"; help+="actualLabel\n"; help+="\tdimensione 1xV\n"; help+="\t(valore della label corrispondente al validation set\n\tNB: salvo un file diverso per ogni label)\n"; help+="trends\n"; help+="\tdimensione RxTrxV\n"; help+="\t(predizione della label, ne ho una diverso per ogni modello\n\tNB: ho un modello diverso per ogni\n\t +ricampionamento delle features\n\t +ricampionamento del training set)\n"; help+="***LEGENDA***\n"; help+="\tR=FeatSelectionRip\n"; help+="\tTs=TsSz\n"; help+="\tTr=TrSz\n"; help+="\tN=NumFeatures\n"; help+="\tV=ValidationSetSize\n"; dims_2[1]=help.size(); dims_2[0]=1; workspace[11] = Mat_VarCreate("README",MAT_C_CHAR,MAT_T_UINT8,2,dims_2,(char*)help.c_str(),0); // Apro scrivo e chiudo il matfile mat_t *Out_MATFILE = Mat_CreateVer((const char*)resFile_.c_str(),NULL,MAT_FT_DEFAULT); for (int iWS=0; iWS<WsSize; ++iWS) Mat_VarWrite(Out_MATFILE, workspace[iWS], MAT_COMPRESSION_NONE); Mat_Close(Out_MATFILE); // ---------------------------------------------------------------------------------------------------------------------- } return; }
void CSMatrix<Scalar>::import_from_file(const char *filename, const char *var_name, MatrixExportFormat fmt, bool invert_storage) { switch (fmt) { case EXPORT_FORMAT_MATRIX_MARKET: throw Exceptions::MethodNotOverridenException("CSMatrix<Scalar>::import_from_file - Matrix Market"); break; case EXPORT_FORMAT_MATLAB_MATIO: { #ifdef WITH_MATIO mat_t *matfp; matvar_t *matvar; matfp = Mat_Open(filename,MAT_ACC_RDONLY); if (!matfp ) { throw Exceptions::IOException(Exceptions::IOException::Read, filename); return; } matvar = Mat_VarRead(matfp, var_name); if (matvar) { mat_sparse_t *sparse = (mat_sparse_t *)matvar->data; this->nnz = sparse->nir; this->Ax = new Scalar[this->nnz]; this->Ai = new int[this->nnz]; this->size = sparse->njc - 1; this->Ap = new int[this->size + 1]; void* data = nullptr; if(Hermes::Helpers::TypeIsReal<Scalar>::value) data = sparse->data; else { std::complex<double>* complex_data = new std::complex<double>[this->nnz]; double* real_array = (double*)((mat_complex_split_t*)sparse->data)->Re; double* imag_array = (double*)((mat_complex_split_t*)sparse->data)->Im; for(int i = 0; i < this->nnz; i++) complex_data[i] = std::complex<double>(real_array[i], imag_array[i]); data = (void*)complex_data; } memcpy(this->Ax, data, this->nnz * sizeof(Scalar)); if(!Hermes::Helpers::TypeIsReal<Scalar>::value) delete [] data; memcpy(this->Ap, sparse->jc, (this->size + 1) * sizeof(Scalar)); memcpy(this->Ai, sparse->ir, this->nnz * sizeof(int)); if(invert_storage) this->switch_orientation(); } Mat_Close(matfp); if(!matvar) throw Exceptions::IOException(Exceptions::IOException::Read, filename); #else throw Exceptions::Exception("MATIO not included."); #endif } break; case EXPORT_FORMAT_PLAIN_ASCII: throw Exceptions::MethodNotOverridenException("CSMatrix<Scalar>::import_from_file - Simple format"); break; } }
G_MODULE_EXPORT void save_as(const char *filename, int type) { FILE *fp; unsigned int i, j; double freq, k; mat_t *mat; matvar_t *matvar; int dims[2]; char tmp[20]; GdkPixbuf *pixbuf; GError *err=NULL; GdkColormap *cmap; gint width, height; gboolean ret = true; char *name; gdouble *tmp_data; name = malloc(strlen(filename) + 5); switch(type) { /* Response Codes encoded in glade file */ case GTK_RESPONSE_DELETE_EVENT: case GTK_RESPONSE_CANCEL: break; case SAVE_VSA: /* Allow saving data when only in Time Domanin */ if ((gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != TIME_PLOT) && (gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != XY_PLOT)) { create_blocking_popup(GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "Invalid Plot Type", "Please make sure to set the Plot Type to \"Time Domanin\" before saving data."); return; } /* Save as Agilent VSA formatted file */ if (!strncasecmp(&filename[strlen(filename)-4], ".txt", 4)) strcpy(name, filename); else sprintf(name, "%s.txt", filename); fp = fopen(name, "w"); if (!fp) break; fprintf(fp, "InputZoom\tTRUE\n"); fprintf(fp, "InputCenter\t0\n"); fprintf(fp, "InputRange\t1\n"); fprintf(fp, "InputRefImped\t50\n"); fprintf(fp, "XStart\t0\n"); if (!strcmp(adc_scale, "M")) freq = adc_freq * 1000000; else if (!strcmp(adc_scale, "k")) freq = adc_freq * 1000; else { printf("error in writing\n"); break; } fprintf(fp, "XDelta\t%-.17f\n", 1.0/freq); fprintf(fp, "XDomain\t2\n"); fprintf(fp, "XUnit\tSec\n"); fprintf(fp, "YUnit\tV\n"); fprintf(fp, "FreqValidMax\t%e\n", freq / 2); fprintf(fp, "FreqValidMin\t-%e\n", freq / 2); fprintf(fp, "Y\n"); for (j = 0; j < num_samples; j++) { for (i = 0; i < num_active_channels ; i++) { fprintf(fp, "%g", channel_data[i][j]); if (i < (num_active_channels - 1)) fprintf(fp, "\t"); } fprintf(fp, "\n"); } fprintf(fp, "\n"); fclose(fp); break; case SAVE_MAT: /* Allow saving data when only in Time Domanin */ if (gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != TIME_PLOT) { create_blocking_popup(GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "Invalid Plot Type", "Please make sure to set the Plot Type to \"Time Domanin\" before saving data."); return; } /* Matlab file * http://na-wiki.csc.kth.se/mediawiki/index.php/MatIO */ if (!strncasecmp(&filename[strlen(filename)-4], ".mat", 4)) strcpy(name, filename); else sprintf(name, "%s.mat", filename); dims[1] = 1; dims[0] = num_samples; mat = Mat_Open(name, MAT_ACC_RDWR); if(mat) { for (i = 0; i < num_active_channels; i++) { sprintf(tmp, "in_voltage%d", i); if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(save_mat_scale))) { matvar = Mat_VarCreate(tmp, MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, channel_data[i], 0); } else { tmp_data = g_new(gdouble, num_samples); if (channels[i].is_signed) k = channels[i].bits_used - 1; else k = channels[i].bits_used; for (j = 0; j < num_samples; j++) { tmp_data[j] = (gdouble)channel_data[i][j] / (pow(2.0, k)); } matvar = Mat_VarCreate(tmp, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, tmp_data, 0); g_free(tmp_data); } if (!matvar) printf("error creating matvar on channel %i\n", i); else { Mat_VarWrite(mat, matvar, 0); Mat_VarFree(matvar); } } Mat_Close(mat); } break; case SAVE_CSV: /* Allow saving data when only in Time Domanin */ if (gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != TIME_PLOT) { create_blocking_popup(GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "Invalid Plot Type", "Please make sure to set the Plot Type to \"Time Domanin\" before saving data."); return; } /* save comma seperated valus (csv) */ if (!strncasecmp(&filename[strlen(filename)-4], ".csv", 4)) strcpy(name, filename); else sprintf(name, "%s.csv", filename); fp = fopen(name, "w"); if (!fp) break; for (j = 0; j < num_samples; j++) { for (i = 0; i < num_active_channels ; i++) { fprintf(fp, "%g", channel_data[i][j]); if (i < (num_active_channels - 1)) fprintf(fp, ", "); } fprintf(fp, "\n"); } fprintf(fp, "\n"); fclose(fp); break; case SAVE_PNG: /* save_png */ if (!strncasecmp(&filename[strlen(filename)-4], ".png", 4)) strcpy(name, filename); else sprintf(name, "%s.png", filename); cmap = gdk_window_get_colormap( GDK_DRAWABLE(gtk_widget_get_window(capture_graph))); gdk_drawable_get_size(GDK_DRAWABLE(gtk_widget_get_window(capture_graph)), &width, &height); pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(gtk_widget_get_window(capture_graph)), cmap, 0, 0, 0, 0, width, height); if (pixbuf) ret = gdk_pixbuf_save(pixbuf, name, "png", &err, NULL); if (!pixbuf || !ret) printf("error creating %s\n", name); break; default: printf("ret : %i\n", ret); } free(name); }