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); }
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; }
double get_double_from_struct_field( matvar_t *eeg, const char *name, int struct_array_index ){ matvar_t *tmp; tmp = Mat_VarGetStructField( eeg, (char*)name, BY_NAME, struct_array_index ); if( tmp->rank != 1 && tmp->dims[0]<1 ){ errprintf("field '%s' wrong, rank=%i,tmp->dims[0]=%i\n",name, tmp->rank,tmp->dims[0] ); return -1; } dprintf( "found: %s=%f\n", name, (((double*)tmp->data)[0]) ); return (((double*)tmp->data)[0]); }
void Cell::loadDef (matvar_t *matVar, int i) { char *variable = new char [7]; matvar_t *field; assert (variable != NULL); strcpy (variable, "def"); field = Mat_VarGetStructField (matVar, (char*) variable, BY_NAME, i); initializeDef (field); delete[] variable; }
int CreateStructVariable(void *pvApiCtx, int iVar, matvar_t *matVariable, int * parent, int item_position) { char **fieldNames = NULL; int nbFields = 0; int fieldIndex = 0; int K = 0; int prodDims = 0; int valueIndex = 0; matvar_t *fieldMatVar = NULL; matvar_t ** allData = NULL; int * cell_addr = NULL; int * cell_entry_addr = NULL; int type; SciErr sciErr; int *piDims = NULL; int i = 0; /* Fields of the struct */ nbFields = 2; /* "st" "dims" */ nbFields += Mat_VarGetNumberOfFields(matVariable); fieldNames = (char**) MALLOC(sizeof(char*) * nbFields); if (fieldNames == NULL) { Scierror(999, _("%s: No more memory.\n"), "CreateStructVariable"); return FALSE; } fieldNames[0] = strdup("st"); if (fieldNames[0] == NULL) { Scierror(999, _("%s: No more memory.\n"), "CreateStructVariable"); return FALSE; } fieldNames[1] = strdup("dims"); if (fieldNames[1] == NULL) { Scierror(999, _("%s: No more memory.\n"), "CreateStructVariable"); return FALSE; } for (fieldIndex = 1; fieldIndex < nbFields - 1; fieldIndex++) { fieldMatVar = Mat_VarGetStructField(matVariable, &fieldIndex, MAT_BY_INDEX, 0); fieldNames[fieldIndex + 1] = strdup(fieldMatVar->name); if (fieldNames[fieldIndex + 1] == NULL) { Scierror(999, _("%s: No more memory.\n"), "CreateStructVariable"); return FALSE; } } /* Returned mlist initialization */ if (parent == NULL) { sciErr = createMList(pvApiCtx, iVar, nbFields, &cell_addr); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } } else { sciErr = createMListInList(pvApiCtx, iVar, parent, item_position, nbFields, &cell_addr); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } } /* FIRST LIST ENTRY: fieldnames */ sciErr = createMatrixOfStringInList(pvApiCtx, iVar, cell_addr, 1, 1, nbFields, fieldNames); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } /* SECOND LIST ENTRY: Dimensions (int32 type) */ if (nbFields == 2) /* Empty struct must have size 0x0 in Scilab */ { matVariable->dims[0] = 0; matVariable->dims[1] = 0; } piDims = (int *) MALLOC(matVariable->rank * sizeof(int)); for (i = 0 ; i < matVariable->rank ; ++i) { piDims[i] = (int)matVariable->dims[i]; } if (matVariable->rank == 2) /* Two dimensions */ { sciErr = createMatrixOfInteger32InList(pvApiCtx, iVar, cell_addr, 2, 1, matVariable->rank, piDims); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } } else /* 3 or more dimensions -> Scilab HyperMatrix */ { type = I_INT32; CreateHyperMatrixVariable(pvApiCtx, iVar, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &type, &matVariable->rank, piDims, (double*)matVariable->data, NULL, cell_addr, 2); } FREE(piDims); /* ALL OTHER ENTRIES: Fields data */ prodDims = 1; for (K = 0; K < matVariable->rank; K++) { prodDims *= (int)matVariable->dims[K]; } allData = (matvar_t**) (matVariable->data); if (prodDims == 1) /* Scalar struct */ { for (fieldIndex = 0; fieldIndex < nbFields - 2; fieldIndex++) { /* Create list entry in the stack */ if (!CreateMatlabVariable(pvApiCtx, iVar, allData[fieldIndex], cell_addr, fieldIndex + 3)) /* Could not Create Variable */ { if (allData[fieldIndex]->class_type != 0) /* class is 0 for not initialized fields */ { sciprint("Do not know how to read a variable of class %d.\n", allData[fieldIndex]->class_type); } } } } else { for (fieldIndex = 0; fieldIndex < nbFields - 2; fieldIndex++) { sciErr = createListInList(pvApiCtx, iVar, cell_addr, fieldIndex + 3, prodDims, &cell_entry_addr); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } for (valueIndex = 0; valueIndex < prodDims; valueIndex++) { /* Create list entry in the stack */ if (!CreateMatlabVariable(pvApiCtx, iVar, allData[(fieldIndex) + (nbFields - 2)*valueIndex], cell_entry_addr, valueIndex + 1)) /* Could not Create Variable */ { if (allData[(fieldIndex) + (nbFields - 2)*valueIndex]->class_type != 0) /* class is 0 for not initialized fields */ { sciprint("Do not know how to read a variable of class %d.\n", allData[(fieldIndex) + (nbFields - 2)*valueIndex]->class_type); } } } } } freeArrayOfString(fieldNames, nbFields); return TRUE; }
/** \brief read EEG struct from EEGlab (MATLAB) .set-file. This reader uses MatIO to parse EEGlab files and construct a LibEEGTools EEG struct. It was developed with EEGlab version 6.01b. Currently, the EEGlab set must be "epoched", that means that the data must be three-dimensional with channels x n x trials. Continuous data is not yet supported and the reader will fail. The reader currently works only if the storage is in single .set file (as opposed to a pair of .set and .dat file). \param file eeglab .set file \return the EEG struct */ EEG* read_eeglab_file( const char *file ){ mat_t *mat; matvar_t *meeg; /* contains the struct 'EEG' from EEGlab */ matvar_t *tmp, *tmp2, *event, *epoch; int nfields; int c,i,j; EEG *eeg; int nbchan, ntrials, n; dprintf("Reading file: '%s'\n", file); mat = Mat_Open( file, MAT_ACC_RDONLY); if( !mat ){ errprintf("Error opening MATLAB file '%s'\n", file ); return NULL; } meeg = Mat_VarRead( mat, "EEG" ); if( meeg->class_type!=MAT_C_STRUCT ){ errprintf("EEG does not appear to be a struct\n" ); return NULL; } nfields = Mat_VarGetNumberOfFields( meeg ); #ifdef DEBUG dprintf( "There are %i fields in the EEG struct\n", nfields ); for( i=1; i<=nfields; i++ ){ /* MATLAB 1-relative indices */ tmp = Mat_VarGetStructField( meeg, &i, BY_INDEX, 0 ); dprintf("Found field: '%s'\n", tmp->name); } #endif /* dimensions */ nbchan = (int)get_double_from_struct_field( meeg, "nbchan",0 ); ntrials= (int)get_double_from_struct_field( meeg, "trials",0 ); n = (int)get_double_from_struct_field( meeg, "pnts",0 ); dprintf("dim=(%i,%i,%i)\n", nbchan,ntrials,n); eeg = eeg_init( nbchan, ntrials, n ); /* filename */ eeg->filename=(char*)malloc( (strlen(file)+2)*sizeof(char) ); strcpy( eeg->filename, file ); /* comments */ tmp = Mat_VarGetStructField( meeg, "comments", BY_NAME, 0 ); eeg->comment=(char*)malloc( tmp->dims[0]*sizeof(char) ); for( i=0; i<tmp->dims[0]+1; i++ ){ eeg->comment[i]='\0'; } memcpy( eeg->comment, tmp->data, tmp->dims[0]*sizeof(char)); /* sampling rate */ eeg->sampling_rate = get_double_from_struct_field( meeg, "srate", 0); /* times */ tmp = Mat_VarGetStructField( meeg, "times", BY_NAME, 0 ); if( tmp->dims[1]==0 && ntrials == 1){ // continuous data dprintf("Continuous data, skipping times-array\n"); } else if( tmp->dims[1]!=n ){ errprintf("times-array should be of length n: %i != %i\n", tmp->dims[1], n ); eeg_free( eeg ); return NULL; } else { if( tmp->data_size != sizeof(double) ){ errprintf("times is not double format, %i!=%li\n", tmp->data_size, sizeof(double)); eeg_free( eeg ); return NULL; } eeg->times=array_new2( DOUBLE, 1, n ); memcpy(eeg->times->data, tmp->data, n*sizeof(double) ); } /* channel info */ eeg->chaninfo = (ChannelInfo*)malloc( nbchan*sizeof(ChannelInfo) ); tmp = Mat_VarGetStructField( meeg, "chanlocs", BY_NAME, 0 ); dprintf("chanlocs: %i,%i\n", tmp->dims[0], tmp->dims[1]); for( i=0; i<nbchan; i++ ){ tmp2 = Mat_VarGetStructField( tmp, "labels", BY_NAME, i ); eeg->chaninfo[i].num = i; eeg->chaninfo[i].num_chans = nbchan; strcpy(eeg->chaninfo[i].label, (char*)tmp2->data); eeg->chaninfo[i].x = get_double_from_struct_field( tmp, "X", i); eeg->chaninfo[i].y = get_double_from_struct_field( tmp, "Y", i); eeg->chaninfo[i].z = get_double_from_struct_field( tmp, "Z", i); } /* data */ tmp = Mat_VarGetStructField( meeg, "data", BY_NAME, 0 ); if( ntrials==1 ) { // continuous data if( tmp->dims[0]!=nbchan || tmp->dims[1]!=n ){ errprintf("(nbchan,n)=(%i,%i), should be (%i,%i)\n", tmp->dims[0], tmp->dims[1], nbchan, n ); eeg_free( eeg ); return NULL; } } else if( tmp->dims[0]!=nbchan || tmp->dims[1]!=n || tmp->dims[2]!=ntrials ){ errprintf("(nbchan,ntrials,n)=(%i,%i,%i), should be (%i,%i,%i)\n", tmp->dims[0], tmp->dims[2], tmp->dims[1], nbchan, ntrials, n ); eeg_free( eeg ); return NULL; } if( tmp->data_size != sizeof(float) ){ errprintf("data is not in float format, sizeof(data)=%i, sizeof(float)=%li\n", tmp->data_size, sizeof(float)); eeg_free( eeg ); return NULL; } float x; for( c=0; c<nbchan; c++ ){ for( i=0; i<ntrials; i++ ){ for( j=0; j<n; j++ ){ x=((float*)tmp->data)[ c + (j*nbchan) + (i*n*nbchan) ]; array_INDEX3(eeg->data,double,c,i,j) = (double)x; } } } /* TODO CONTINUE HERE */ /* /\* markers *\/ */ /* epoch = Mat_VarGetStructField( meeg, "epoch", BY_NAME, 0 ); */ /* if( epoch->dims[0] == 0 || epoch->dims[1] < ntrials ){ */ /* warnprintf("no epoch field, or wrong dimensions (%i,%i), skipping...\n", */ /* epoch->dims[0],epoch->dims[1]); */ /* } else { */ /* eeg->nmarkers = (unsigned int*) malloc( ntrials*sizeof(unsigned int) ); */ /* eeg->markers = (unsigned int**) malloc( ntrials*sizeof(unsigned int*) ); */ /* eeg->marker_labels = (char***) malloc( ntrials*sizeof(char**) ); */ /* for( i=0; i<ntrials; i++ ){ */ /* tmp = Mat_VarGetStructField( epoch, "eventlatency", BY_NAME, i ); */ /* tmp2 = Mat_VarGetStructField( epoch, "eventtype", BY_NAME, i ); */ /* dprintf("%i, %i\n", i, tmp->dims[1]); */ /* eeg->nmarkers[i] = tmp->dims[1]; */ /* eeg->markers[i] = (unsigned int*) malloc( eeg->nmarkers[i]*sizeof(unsigned int) ); */ /* eeg->marker_labels[i] = (char**) malloc( eeg->nmarkers[i]*sizeof(char*) ); */ /* for( j=0; j<eeg->nmarkers[i]; j++ ){ */ /* /\* label *\/ */ /* event = Mat_VarGetCell( tmp2, j ); /\* MATLAB index *\/ */ /* eeg->marker_labels[i][j] = (char*)malloc( (strlen((char*)event->data)+1)*sizeof(char) ); */ /* strcpy( eeg->marker_labels[i][j], (char*)event->data ); */ /* /\* latency *\/ */ /* event = Mat_VarGetCell( tmp, j ); /\* MATLAB index *\/ */ /* eeg->markers[i][j] = closest_index( eeg->times, n, ((double*)event->data)[0] ); */ /* } */ /* } */ /* } */ dprintf("Finished reading '%s'\n", file ); return eeg; }