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;
}
/** @brief Creates a structure MATLAB variable with the given name and fields
*
* @ingroup MAT
* @param name Name of the structure variable to create
* @param rank Rank of the variable
* @param dims array of dimensions of the variable of size rank
* @param fields Array of @c nfields fieldnames
* @param nfields Number of fields in the structure
* @param matvar Pointer to store the new structure MATLAB variable
* @return @c MATIO_SUCCESS if successful, or an error value (See
* @ref enum matio_error_t).
*/
matvar_t *
Mat_VarCreateStruct(const char *name,int rank,size_t *dims,const char **fields,
unsigned nfields)
{
int i, nmemb = 1;
matvar_t *matvar;
if ( NULL == dims )
return NULL;
matvar = Mat_VarCalloc();
if ( NULL == matvar )
return NULL;
matvar->compression = MAT_COMPRESSION_NONE;
if ( NULL != name )
matvar->name = strdup(name);
matvar->rank = rank;
matvar->dims = malloc(matvar->rank*sizeof(*matvar->dims));
for ( i = 0; i < matvar->rank; i++ ) {
matvar->dims[i] = dims[i];
nmemb *= dims[i];
}
matvar->class_type = MAT_C_STRUCT;
matvar->data_type = MAT_T_STRUCT;
matvar->data_size = sizeof(matvar_t *);
if ( nfields ) {
matvar->internal->num_fields = nfields;
matvar->internal->fieldnames =
malloc(nfields*sizeof(*matvar->internal->fieldnames));
if ( NULL == matvar->internal->fieldnames ) {
Mat_VarFree(matvar);
matvar = NULL;
} else {
for ( i = 0; i < nfields; i++ ) {
if ( NULL == fields[i] ) {
Mat_VarFree(matvar);
matvar = NULL;
break;
} else {
matvar->internal->fieldnames[i] = strdup(fields[i]);
}
}
}
if ( NULL != matvar && nmemb > 0 && nfields > 0 ) {
matvar_t **field_vars;
matvar->nbytes = nmemb*nfields*matvar->data_size;
matvar->data = malloc(matvar->nbytes);
field_vars = (matvar_t**)matvar->data;
for ( i = 0; i < nfields*nmemb; i++ )
field_vars[i] = NULL;
}
}
return matvar;
}
void extra_matio_print_all_var_info (mat_t * matfp, int printdata) {
matvar_t *matvar;
fflush(stdout);
if (printdata)
while ( NULL != (matvar = Mat_VarReadNext(matfp)) ) {
Mat_VarPrint(matvar,printdata);
Mat_VarFree(matvar);
}
else
while ( NULL != (matvar = Mat_VarReadNextInfo(matfp)) ) {
Mat_VarPrint(matvar,printdata);
Mat_VarFree(matvar);
}
fflush(stdout);
}
void extra_matio_print_all_var_info_clumsy(mat_t * matfp) {
matvar_t *matvar;
size_t nbytes;
int i;
char size[32] = {' ',};
fflush(stdout);
printf( "%-20s %-10s %-10s %-18s\n", "Name", "Size", "Bytes", "Class");
while ( NULL != (matvar = Mat_VarReadNextInfo(matfp)) ) {
printf("%-20s", matvar->name);
if ( matvar->rank > 0 ) {
int cnt = 0;
printf("%8d", matvar->dims[0]);
for ( i = 1; i < matvar->rank; i++ ) {
if ( ceil(log10(matvar->dims[i]))+1 < 32 )
cnt += sprintf(size+cnt,"x%d", matvar->dims[i]);
}
printf("%-10s",size);
} else {
printf(" ");
}
nbytes = Mat_VarGetSize(matvar);
printf(" %8d",nbytes);
printf(" %-18s\n",mxclass[matvar->class_type-1]);
Mat_VarPrint(matvar,0);
Mat_VarFree(matvar);
}
fflush(stdout);
}
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;
}
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;
}
/**
* @brief Execute commands to read from data from a structure array
*
* @param pStruct Pointer to the structure array variable
* @param ix index of this arcset within the structure array
* @param refLaws Reference to a vector of ControlLaw pointers. As control laws are read
* from the Matlab file, unique control laws are constructed and allocated on the stack.
* The user must manually delete the ControlLaw objects to avoid memory leaks.
*/
void Arcset_bc4bp::readCmds_fromStruct(matvar_t *pStruct, unsigned int ix, std::vector<ControlLaw*> &refLaws){
Arcset::readCmds_fromStruct(pStruct, ix, refLaws);
matvar_t *pEpochDeriv = Mat_VarGetStructFieldByName(pStruct, VARNAME_STATE_EPOCH_DERIV, ix);
if(readVar_NodeExtraParamVec(pEpochDeriv, PARAMKEY_STATE_EPOCH_DERIV, 6, Save_tp::SAVE_ALL)){
Mat_VarFree(pEpochDeriv);
}
}//====================================================
/**
* @brief Execute commands to read data from a Matlab file
* @param pMatFile pointer to an open Matlab file
* @param refLaws Reference to a vector of ControlLaw pointers. As control laws are read
* from the Matlab file, unique control laws are constructed and allocated on the stack.
* The user must manually delete the ControlLaw objects to avoid memory leaks.
*/
void Arcset_bc4bp::readCmds_fromFile(mat_t *pMatFile, std::vector<ControlLaw*> &refLaws){
Arcset::readCmds_fromFile(pMatFile, refLaws);
matvar_t *pEpochDeriv = Mat_VarRead(pMatFile, VARNAME_STATE_EPOCH_DERIV);
if(readVar_NodeExtraParamVec(pEpochDeriv, PARAMKEY_STATE_EPOCH_DERIV, 6, Save_tp::SAVE_ALL)){
Mat_VarFree(pEpochDeriv);
}
}//====================================================
/** \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;
}
/**
* @brief Execute commands to read from data from a structure array
*
* @param pStruct Pointer to the structure array variable
* @param ix index of this arcset within the structure array
* @param refLaws Reference to a vector of ControlLaw pointers. As control laws
* are read from the Matlab file, unique control laws are constructed and
* allocated on the stack. The user must manually delete the ControlLaw objects
* to avoid memory leaks.
*/
void Arcset_cr3bp::readCmds_fromStruct(matvar_t *pStruct, unsigned int ix,
std::vector<ControlLaw*> &refLaws){
Arcset::readCmds_fromStruct(pStruct, ix, refLaws);
matvar_t *pJacobi = Mat_VarGetStructFieldByName(pStruct, VARNAME_JACOBI, ix);
if(readVar_NodeExtraParam(pJacobi, PARAMKEY_JACOBI, Save_tp::SAVE_ALL)){
Mat_VarFree(pJacobi);
}
}//====================================================
/**
* @brief Execute commands to read data from a Matlab file
* @param pMatFile pointer to an open Matlab file
* @param refLaws Reference to a vector of ControlLaw pointers. As control laws
* are read from the Matlab file, unique control laws are constructed and
* allocated on the stack. The user must manually delete the ControlLaw objects
* to avoid memory leaks.
*/
void Arcset_cr3bp::readCmds_fromFile(mat_t *pMatFile,
std::vector<ControlLaw*> &refLaws){
Arcset::readCmds_fromFile(pMatFile, refLaws);
matvar_t *pJacobi = Mat_VarRead(pMatFile, VARNAME_JACOBI);
if(readVar_NodeExtraParam(pJacobi, PARAMKEY_JACOBI, Save_tp::SAVE_ALL)){
Mat_VarFree(pJacobi);
}
}//====================================================
int matArrNCol (char *name)
{
int ncol = 0;
matvar_t *matvar = Mat_VarRead(mat_file, name);
if (matvar == NULL)
return -1;
ncol = matvar->dims[1];
Mat_VarFree(matvar);
return ncol;
}
int matArrNRow (char *name)
{
int nrow = 0;
matvar_t *matvar = Mat_VarRead(mat_file, name);
if (matvar == NULL)
return -1;
nrow = matvar->dims[0];
Mat_VarFree(matvar);
return nrow;
}
int matGetInt (char *name,int n1,int n2, int *data)
{
matvar_t *matvar;
matvar = Mat_VarRead(mat_file, name);
if (matvar == NULL)
return -1;
memcpy(data, matvar->data, n1*n2*sizeof(int));
Mat_VarFree(matvar);
return 0;
}
/* put string in mat file*/
void matPutStr (char *name,char *str)
{
matvar_t *matvar = NULL;
size_t dims[2];
dims[0] = 1;
dims[1] = strlen(str);
matvar = Mat_VarCreate(name, MAT_C_CHAR, MAT_T_UINT8, 2, dims, str, MAT_F_DONT_COPY_DATA);
Mat_VarWrite(mat_file, matvar, MAT_COMPRESSION_NONE);
Mat_VarFree(matvar);
}
/* put integer in mat file*/
void matPutInt (char *name,int n1,int n2, int *pd)
{
matvar_t *matvar = NULL;
size_t dims[2];
dims[0] = n1;
dims[1] = n2;
matvar = Mat_VarCreate(name, MAT_C_INT32, MAT_T_INT32, 2, dims, pd, MAT_F_DONT_COPY_DATA);
Mat_VarWrite(mat_file, matvar, MAT_COMPRESSION_ZLIB);
Mat_VarFree(matvar);
}
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 MatFileIO::getSparseVariableViaName(sparse_t & sparseVariable, std::string _name) {
matvar_t * matvar = getVariableViaName(_name);
if (matvar == NULL) {
fthrow(Exception, "MatFileIO::getSparseVariableViaName(sparse_t & sparseVariable, std::string _name): variable with specified name does not exist");
return;
}
if (matvar->class_type != MAT_C_SPARSE) {
Mat_VarFree(matvar);
fthrow(Exception, "MatFileIO::getSparseVariableViaName(sparse_t & sparseVariable, std::string _name): format of variable is not sparse");
return;
}
sparse_t * sparse_ptr = (sparse_t*) matvar->data;
sparse_ptr->data = (double*) sparse_ptr->data;
sparseVariable = *sparse_ptr;
matvar->data = NULL;
Mat_VarFree(matvar);
free(sparse_ptr);
}
int MatFileIO::getNumberOfVariables() {
Mat_Rewind(mat); // get back to first variable
int count = 0;
matvar_t * matvar = Mat_VarReadNextInfo(mat);
while (matvar != NULL) {
count++;
matvar = Mat_VarReadNextInfo(mat);
}
Mat_VarFree(matvar);
return count;
}
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;
}
/* put string in mat file*/
int matPutStr (const char *name, char *str)
{
int error = 0;
matvar_t *matvar = nullptr;
size_t dims[2];
dims[0] = 1;
dims[1] = strlen(str);
matvar = Mat_VarCreate(name, MAT_C_CHAR, MAT_T_UINT8, 2, dims, str, MAT_F_DONT_COPY_DATA);
if (matvar != nullptr) {
error = Mat_VarWrite(mat_file, matvar, MAT_COMPRESSION_NONE);
Mat_VarFree(matvar);
} else {
error = 1;
}
return error;
}
static FMatrix_ptr read_matrix_in_mat(mat_t * mat, const char *varname)
{
matvar_t * tvar = Mat_VarRead(mat, varname);
int rows = tvar->dims[0];
int columns = tvar->dims[1];
std::cout<<rows<<" "<<columns<<std::endl;
uint8_t * pData = static_cast<uint8_t *>(tvar->data);
FMatrix_ptr res = std::make_shared<FMatrix>(rows, columns);
for(int k = 0; k < rows; ++k)
{
for(int i = 0; i < columns; ++i)
{
res->operator()(k, i) = static_cast<double>(pData[rows * i + k]);
}
}
Mat_VarFree(tvar);
return res;
}
/* put integer in mat file*/
int matPutInt (const char *name,int n1,int n2, int *pd)
{
int error = 0;
matvar_t *matvar = nullptr;
size_t dims[2];
dims[0] = n1;
dims[1] = n2;
matvar = Mat_VarCreate(name, MAT_C_INT32, MAT_T_INT32, 2, dims, pd, MAT_F_DONT_COPY_DATA);
if (matvar != nullptr) {
error = Mat_VarWrite(mat_file, matvar, MAT_COMPRESSION_ZLIB);
Mat_VarFree(matvar);
} else {
error = 1;
}
return error;
}
int matGetStr (char *name,char *data)
{
int strlen;
matvar_t *matvar;
matvar = Mat_VarRead(mat_file, name);
if (matvar == NULL)
return -1;
strlen = matvar->nbytes;
if (matvar->dims[0] != 1)
printf("Error: Multiline string copy attempted\n");
memcpy(data, matvar->data, strlen);
Mat_VarFree(matvar);
return 0;
}
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;
}
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;
}
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);
}
