コード例 #1
0
ファイル: berkeley.cpp プロジェクト: ILoveFree2/gop
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;
}
コード例 #2
0
ファイル: DataOutputNode.cpp プロジェクト: ndoxx/BinnoBot
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;
}
コード例 #3
0
ファイル: Functions.cpp プロジェクト: guroseternes/Master
void readHeightAndTopSurfaceFromMATLABFile(const char* filename, CpuPtr_2D& H, CpuPtr_2D& top_surface, int& nx, int& ny){

mat_t *matfp;
matvar_t *matvar;
matfp = Mat_Open(filename, MAT_ACC_RDONLY);
if ( NULL == matfp ) {
	fprintf(stderr,"Error opening MAT file");
}

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
nx = matvar->dims[0];
ny = matvar->dims[1];
int size = nx*ny;
H = CpuPtr_2D(nx, ny, 0, true);
memcpy(H.getPtr(), matvar->data,sizeof(float)*size);
Mat_VarFree(matvar);
matvar = NULL;

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
top_surface = CpuPtr_2D(nx, ny, 0, true);
memcpy(top_surface.getPtr(), matvar->data,sizeof(float)*size);
Mat_VarFree(matvar);
matvar = NULL;
}
コード例 #4
0
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);
}
コード例 #5
0
ファイル: io_matlab.c プロジェクト: ihrke/libeegtools
/** \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;
}
コード例 #6
0
ファイル: MatFileIO.cpp プロジェクト: K4stor/nice-core
      // Recommended constructor
      MatFileIO::MatFileIO(std::string _filename, const mat_acc mode) { 
	
	mat = Mat_Open(_filename.c_str(),mode); 
	
	if (mat == NULL && mode == MAT_ACC_RDONLY) {
	 
	  fthrow(Exception, "MatFileIO::MatFileIO(const char * _filename, int mode): mat-file does not exist");
	  
	}
      } 
コード例 #7
0
ファイル: matlab.c プロジェクト: Ikulagin/transmem
static int
ismat( const char *filename )
{
	mat_t *mat;

	if( !(mat = Mat_Open( filename, MAT_ACC_RDONLY )) )
		return( 0 );
	Mat_Close( mat );

	return( 1 );
}
コード例 #8
0
ファイル: matlab.c プロジェクト: achanda101/libvips
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 );
}
コード例 #9
0
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;
}
コード例 #10
0
ファイル: read.cpp プロジェクト: AthrunArthur/ffsae
 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;
 }
コード例 #11
0
ファイル: matlab.c プロジェクト: achanda101/libvips
static Read *
read_new( const char *filename, VipsImage *out )
{
	Read *read;

	if( !(read = VIPS_NEW( NULL, Read )) )
		return( NULL );

	read->filename = vips_strdup( NULL, filename );
	read->out = out;
	read->mat = NULL;
	read->var = NULL;

	if( !(read->mat = Mat_Open( filename, MAT_ACC_RDONLY )) ) {
		vips_error( "mat2vips", 
			_( "unable to open \"%s\"" ), filename );
		read_destroy( read );
		return( NULL );
	}

	for(;;) {
		if( !(read->var = Mat_VarReadNextInfo( read->mat )) ) {
			vips_error( "mat2vips", 
				_( "no matrix variables in \"%s\"" ), 
				filename );
			read_destroy( read );
			return( NULL );
		}

#ifdef DEBUG
		printf( "mat2vips: seen:\n" );
		printf( "var->name == %s\n", read->var->name );
		printf( "var->class_type == %d\n", read->var->class_type );
		printf( "var->rank == %d\n", read->var->rank );
#endif /*DEBUG*/

		/* Vector to colour image is OK for us.
		 */
		if( read->var->rank >= 1 && read->var->rank <= 3 )
			break;

		VIPS_FREEF( Mat_VarFree, read->var );
	}

	return( read );
}
コード例 #12
0
ファイル: DataOutputNode.cpp プロジェクト: ndoxx/BinnoBot
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;
}
コード例 #13
0
ファイル: Functions.cpp プロジェクト: guroseternes/Master
void readPermFromMATLABFile(const char* filename, CpuPtr_3D& perm3D){

mat_t *matfp;
matvar_t *matvar;
matfp = Mat_Open(filename, MAT_ACC_RDONLY);
if ( NULL == matfp ) {
	fprintf(stderr,"Error opening MAT file");
}

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
int nx = matvar->dims[0];
int ny = matvar->dims[1];
int nz = matvar->dims[2];
nz = 20;
int size = nx*ny*nz;
perm3D = CpuPtr_3D(nx, ny, nz, 0, true);
memcpy(perm3D.getPtr(), matvar->data,sizeof(float)*size);
Mat_VarFree(matvar);
matvar = NULL;
}
コード例 #14
0
ファイル: matio.c プロジェクト: hcho3/dstedc_mgpu
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;
}
コード例 #15
0
/*******************************************************************************
   Interface for MATIO function called Mat_Open
   Scilab function name : matfile_open
*******************************************************************************/
int sci_matfile_open(char *fname, void* pvApiCtx)
{
    int nbRow = 0, nbCol = 0;
    mat_t *matfile;
    int fileIndex = 0;
    char * filename  = NULL;
    char * optionStr = NULL;
    int option = 0, var_type;
    int * filename_addr = NULL, * option_addr = NULL, * version_addr = NULL;
    char * versionStr = NULL;
    int version = MAT_FT_MAT5; // By default, use MAtlab 5 files
    SciErr sciErr;

    CheckRhs(1, 3);
    CheckLhs(1, 1);

    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &filename_addr);
    if (sciErr.iErr)
    {
        printError(&sciErr, 0);
        return 0;
    }
    sciErr = getVarType(pvApiCtx, filename_addr, &var_type);
    if (sciErr.iErr)
    {
        printError(&sciErr, 0);
        return 0;
    }

    if (var_type == sci_strings)
    {
        getAllocatedSingleString(pvApiCtx, filename_addr, &filename);
        sciErr = getVarDimension(pvApiCtx, filename_addr, &nbRow, &nbCol);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return 0;
        }

        if (nbCol != 1)
        {
            Scierror(999, _("%s: Wrong size for first input argument: string expected.\n"), fname);
            freeAllocatedSingleString(filename);
            return FALSE;
        }
    }
    else
    {
        Scierror(999, _("%s: Wrong type for first input argument: string expected.\n"), fname);
        freeAllocatedSingleString(filename);
        return FALSE;
    }

    if (Rhs >= 2)
    {
        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &option_addr);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return 0;
        }

        sciErr = getVarType(pvApiCtx, option_addr, &var_type);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return 0;
        }

        if (var_type == sci_strings)
        {
            getAllocatedSingleString(pvApiCtx, option_addr, &optionStr);
            sciErr = getVarDimension(pvApiCtx, option_addr, &nbRow, &nbCol);
            if (sciErr.iErr)
            {
                printError(&sciErr, 0);
                return 0;
            }

            if (nbCol != 1)
            {
                Scierror(999, _("%s: Wrong size for second input argument: string expected.\n"), fname);
                freeAllocatedSingleString(filename);
                freeAllocatedSingleString(optionStr);

                return FALSE;
            }

            if (strcmp(optionStr, "r") == 0)
            {
                option = MAT_ACC_RDONLY;
            }
            else if (strcmp(optionStr, "w") == 0)
            {
                option = MAT_ACC_RDWR;
            }
            else
            {
                Scierror(999, _("%s: Wrong value for second input argument: 'r' or 'w' expected.\n"), fname);
                freeAllocatedSingleString(filename);
                freeAllocatedSingleString(optionStr);

                return FALSE;
            }
        }
        else
        {
            Scierror(999, _("%s: Wrong type for second input argument: string expected.\n"), fname);
            freeAllocatedSingleString(filename);
            freeAllocatedSingleString(optionStr);

            return FALSE;
        }
    }
    else
    {
        /* Default option value */
        option = MAT_ACC_RDONLY;
    }

    if (Rhs >= 3)
    {
        sciErr = getVarAddressFromPosition(pvApiCtx, 3, &version_addr);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return 0;
        }

        sciErr = getVarType(pvApiCtx, version_addr, &var_type);
        if (sciErr.iErr)
        {
            printError(&sciErr, 0);
            return 0;
        }
        printf("sci_strings %d %d\n", var_type, sci_strings);
        if (var_type == sci_strings)
        {
            getAllocatedSingleString(pvApiCtx, version_addr, &versionStr);
            sciErr = getVarDimension(pvApiCtx, version_addr, &nbRow, &nbCol);
            if (sciErr.iErr)
            {
                printError(&sciErr, 0);
                return 0;
            }
            if (nbCol != 1)
            {
                Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 3);
                freeAllocatedSingleString(filename);
                freeAllocatedSingleString(optionStr);
                freeAllocatedSingleString(versionStr);

                return FALSE;
            }

            if (strcmp(versionStr, "7.3") == 0)
            {
                version = MAT_FT_MAT73; // Matlab 7.3 file
            }
            else
            {
                version = MAT_FT_MAT5; // Default, Matlab 5 file
            }
        }
        else
        {
            Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 3);
            return 0;
        }
    }

    if (option == MAT_ACC_RDWR) // Write, option = "w"
    {
        /* create a Matlab 5 or 7.3 file */
        matfile = Mat_CreateVer(filename, NULL, version);
    }
    else // Read, option = "r"
    {
        /* Try to open the file (as a Matlab 5 file) */
        matfile = Mat_Open(filename, option);
    }

    if (matfile == NULL) /* Opening failed */
    {
        /* Function returns -1 */
        fileIndex = -1;
    }

    if (matfile != NULL) /* Opening succeed */
    {
        /* Add the file to the manager */
        matfile_manager(MATFILEMANAGER_ADDFILE, &fileIndex, &matfile);
    }

    /* Return the index */
    createScalarDouble(pvApiCtx, Rhs + 1, (double)fileIndex);

    freeAllocatedSingleString(filename);
    freeAllocatedSingleString(optionStr);
    freeAllocatedSingleString(versionStr);

    LhsVar(1) = Rhs + 1;
    PutLhsVar();

    return TRUE;
}
コード例 #16
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
}
コード例 #17
0
ファイル: Functions.cpp プロジェクト: guroseternes/Master
void readFormationDataFromMATLABFile(const char* filename, CpuPtr_2D& H, CpuPtr_2D& top_surface, CpuPtr_2D& h,
									CpuPtr_2D& z_normal, CpuPtr_3D& perm3D, float* poro3D, CpuPtr_2D& pv,
									CpuPtr_2D& north_flux, CpuPtr_2D& east_flux,
									CpuPtr_2D& north_grav, CpuPtr_2D& east_grav,
									float& dz, int&nz, int& nx, int& ny){

mat_t *matfp;
matvar_t *matvar;
matfp = Mat_Open(filename, MAT_ACC_RDONLY);
if ( NULL == matfp ) {
	fprintf(stderr,"Error opening MAT file");
}

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
nz = *(float*)matvar->data;
Mat_VarFree(matvar);
matvar = NULL;

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
nx = matvar->dims[0];
ny = matvar->dims[1];
int size = nx*ny;
H = CpuPtr_2D(nx, ny, 0, true);
memcpy(H.getPtr(), matvar->data,sizeof(float)*size);
Mat_VarFree(matvar);
matvar = NULL;

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
h = CpuPtr_2D(nx, ny, 0, true);
memcpy(h.getPtr(), matvar->data,sizeof(float)*size);
Mat_VarFree(matvar);
matvar = NULL;

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
top_surface = CpuPtr_2D(nx, ny, 0, true);
memcpy(top_surface.getPtr(), matvar->data,sizeof(float)*size);
Mat_VarFree(matvar);
matvar = NULL;

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
pv = CpuPtr_2D(nx, ny, 0, true);
memcpy(pv.getPtr(), matvar->data,sizeof(float)*size);
Mat_VarFree(matvar);
matvar = NULL;

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
east_flux = CpuPtr_2D(nx, ny, 1, true);
memcpy(east_flux.getPtr(), matvar->data,sizeof(float)*(nx+1)*(ny+1));
Mat_VarFree(matvar);
matvar = NULL;

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
north_flux = CpuPtr_2D(nx, ny, 1, true);
memcpy(north_flux.getPtr(), matvar->data,sizeof(float)*(nx+1)*(ny+1));
Mat_VarFree(matvar);
matvar = NULL;

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
z_normal = CpuPtr_2D(nx, ny, 0, true);
memcpy(z_normal.getPtr(), matvar->data,sizeof(float)*size);
Mat_VarFree(matvar);
matvar = NULL;

//perm3D = CpuPtr_3D(nx, ny, nz, 0, true);
matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
nx = matvar->dims[0];
ny = matvar->dims[1];
nz = matvar->dims[2];
printf("3D dims: nx %i ny %i nz %i\n", nx, ny, nz);
//memcpy(perm3D.getPtr(), matvar->data,sizeof(float)*nx*ny*nz);
Mat_VarFree(matvar);
matvar = NULL;

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
//poro3D = CpuPtr_3D(nx, ny, nz, 0, true);
memcpy(poro3D, matvar->data,sizeof(float)*nx*ny*nz);
Mat_VarFree(matvar);
matvar = NULL;

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
dz = *(float*)matvar->data;
Mat_VarFree(matvar);
matvar = NULL;

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
north_grav = CpuPtr_2D(nx, ny, 0, true);
memcpy(north_grav.getPtr(), matvar->data,sizeof(float)*size);
Mat_VarFree(matvar);
matvar = NULL;

matvar = Mat_VarReadNextInfo(matfp);
Mat_VarReadDataAll(matfp, matvar);
printf("Variable: %s\n",matvar->name);
east_grav = CpuPtr_2D(nx, ny, 0, true);
memcpy(east_grav.getPtr(), matvar->data,sizeof(float)*size);
Mat_VarFree(matvar);
matvar = NULL;

}
コード例 #18
0
ファイル: cs_matrix.cpp プロジェクト: HPeX/hermes
    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;
      }
    }
コード例 #19
0
ファイル: vector.cpp プロジェクト: Manguydudebro/hermes
    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");
      }

    }
コード例 #20
0
ファイル: vector.cpp プロジェクト: LeiDai/hermes
    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
      }
    }
コード例 #21
0
ファイル: mat2exo.c プロジェクト: 00liujj/trilinos
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);
}
コード例 #22
0
ファイル: matdump.c プロジェクト: agramfort/matio-openmeeg
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;
}
コード例 #23
0
ファイル: dialogs.c プロジェクト: jagsmani/iio-oscilloscope
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);
}
コード例 #24
0
ファイル: io_matlab.c プロジェクト: ihrke/libeegtools
/** \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;
}
コード例 #25
0
ファイル: cs_matrix.cpp プロジェクト: Manguydudebro/hermes
    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;
      }
    }
コード例 #26
0
ファイル: io_matlab.c プロジェクト: ihrke/libeegtools
/** \brief read a MATLAB-array from a .mat file.
	 
	 \todo Currently, the returned array is always DOUBLE.

	 \param file the .mat file
	 \param varname the name of the variable in the .mat file; can be NULL, in this case the
	       first variable is read.
	 \return the Array-struct or NULL in case an error occurred
 */
Array* read_array_matlab( const char *file, const char *varname ){ 
  mat_t *mfile;
  matvar_t *marr=NULL;

  dprintf("Reading variable '%s' from file: '%s'\n", varname, file);
  mfile = Mat_Open( file, MAT_ACC_RDONLY);
  if( !mfile ){
	 errprintf("Error opening MATLAB file '%s'\n", file );
	 return NULL;
  }

  if( varname ){
	 marr = Mat_VarRead( mfile, varname );
  } else {
	 marr = Mat_VarReadNext( mfile );
  }
  Mat_Close( mfile );
  dprintf("Done\n");

  if( !marr ){
	 errprintf("Something is wrong, could not read variable\n");
	 return NULL;
  }
  Array *out=array_new( DOUBLE, marr->rank, marr->dims );

  ulong i; 
  uint *index=(uint*)malloc( out->ndim*sizeof(uint));
  for( i=0; i<marr->nbytes/marr->data_size; i++ ){
	 array_calc_colindex( i, out->size, out->ndim, index );
	 
	 switch( marr->data_type ){
	 case MAT_T_INT8:
		*((double*)array_index(out,index))=(double)(*(int8_t*)(marr->data+(i*marr->data_size))); 
		break;
	 case MAT_T_UINT8:
		*((double*)array_index(out,index))=(double)(*(uint8_t*)(marr->data+(i*marr->data_size)));
		break;
	 case MAT_T_INT16:
		*((double*)array_index(out,index))=(double)(*(int16_t*)(marr->data+(i*marr->data_size)));
		break;
	 case MAT_T_UINT16:
		*((double*)array_index(out,index))=(double)(*(uint16_t*)(marr->data+(i*marr->data_size)));
		break;
	 case MAT_T_INT32:
		*((double*)array_index(out,index))=(double)(*(int32_t*)(marr->data+(i*marr->data_size)));
		break;
	 case MAT_T_UINT32:
		*((double*)array_index(out,index))=(double)(*(uint32_t*)(marr->data+(i*marr->data_size)));
		break;
	 case MAT_T_INT64:
		*((double*)array_index(out,index))=(double)(*(int64_t*)(marr->data+(i*marr->data_size)));
		break;
	 case MAT_T_UINT64:
		*((double*)array_index(out,index))=(double)(*(uint64_t*)(marr->data+(i*marr->data_size)));
		break;
	 case MAT_T_SINGLE:
		*((double*)array_index(out,index))=(double)(*(float*)(marr->data+(i*marr->data_size)));
		break;
	 case MAT_T_DOUBLE:
		*((double*)array_index(out,index))=(double)(*(double*)(marr->data+(i*marr->data_size)));
		break;
	 default:
		errprintf("Unknown Data-Type in MATLAB-file!\n");
		break;
	 }
  }
  free(index);
  
  return out;
}