#include <src/libigl/igl/matlab/MatlabWorkspace.h>

Collaboration diagram for igl::matlab::MatlabWorkspace:

Public Member Functions
	MatlabWorkspace ()

	~MatlabWorkspace ()

void	clear ()

bool	write (const std::string &path) const

bool	read (const std::string &path)

template<typename DerivedM >
MatlabWorkspace &	save (const Eigen::PlainObjectBase< DerivedM > &M, const std::string &name)

template<typename MT >
MatlabWorkspace &	save (const Eigen::SparseMatrix< MT > &M, const std::string &name)

template<typename ScalarM >
MatlabWorkspace &	save (const std::vector< std::vector< ScalarM > > &vM, const std::string &name)

template<typename ScalarV >
MatlabWorkspace &	save (const std::vector< ScalarV > &vV, const std::string &name)

template<typename Q >
MatlabWorkspace &	save (const Eigen::Quaternion< Q > &q, const std::string &name)

MatlabWorkspace &	save (const double d, const std::string &name)

template<typename DerivedM >
MatlabWorkspace &	save_index (const Eigen::DenseBase< DerivedM > &M, const std::string &name)

template<typename ScalarM >
MatlabWorkspace &	save_index (const std::vector< std::vector< ScalarM > > &vM, const std::string &name)

template<typename ScalarV >
MatlabWorkspace &	save_index (const std::vector< ScalarV > &vV, const std::string &name)

template<typename DerivedM >
bool	find (const std::string &name, Eigen::PlainObjectBase< DerivedM > &M)

template<typename MT >
bool	find (const std::string &name, Eigen::SparseMatrix< MT > &M)

bool	find (const std::string &name, double &d)

bool	find (const std::string &name, int &v)

template<typename DerivedM >
bool	find_index (const std::string &name, Eigen::PlainObjectBase< DerivedM > &M)

template<typename DerivedM >
igl::matlab::MatlabWorkspace &	save (const Eigen::PlainObjectBase< DerivedM > &M, const std::string &name)

template<typename MT >
igl::matlab::MatlabWorkspace &	save (const Eigen::SparseMatrix< MT > &M, const std::string &name)

template<typename ScalarM >
igl::matlab::MatlabWorkspace &	save (const std::vector< std::vector< ScalarM > > &vM, const std::string &name)

template<typename ScalarV >
igl::matlab::MatlabWorkspace &	save (const std::vector< ScalarV > &vV, const std::string &name)

template<typename Q >
igl::matlab::MatlabWorkspace &	save (const Eigen::Quaternion< Q > &q, const std::string &name)

template<typename DerivedM >
igl::matlab::MatlabWorkspace &	save_index (const Eigen::DenseBase< DerivedM > &M, const std::string &name)

template<typename ScalarM >
igl::matlab::MatlabWorkspace &	save_index (const std::vector< std::vector< ScalarM > > &vM, const std::string &name)

template<typename ScalarV >
igl::matlab::MatlabWorkspace &	save_index (const std::vector< ScalarV > &vV, const std::string &name)

Private Attributes
std::vector< std::string >	names

std::vector< mxArray * >	data

Detailed Description

Constructor & Destructor Documentation

◆ MatlabWorkspace()

igl::matlab::MatlabWorkspace::MatlabWorkspace ( )

inline

                                                :
  names(),
  data()
{
}

◆ ~MatlabWorkspace()

igl::matlab::MatlabWorkspace::~MatlabWorkspace ( )

inline

{
  // clean up data
  clear();
}

Member Function Documentation

◆ clear()

void igl::matlab::MatlabWorkspace::clear ( )

inline

{
  for_each(data.begin(),data.end(),&mxDestroyArray);
  data.clear();
  names.clear();
}

References igl::for_each().

Here is the call graph for this function:

◆ find() [1/4]

bool igl::matlab::MatlabWorkspace::find	(	const std::string &	name,
		double &	d
	)

inline

{
  using namespace std;
  const int i = std::find(names.begin(), names.end(), name)-names.begin();
  if(i>=(int)names.size())
  {
    return false;
  }
  assert(i<=(int)data.size());
  mxArray * mx_data = data[i];
  assert(!mxIsSparse(mx_data));
  assert(mxGetNumberOfDimensions(mx_data) == 2);
  //cout<<name<<": "<<mxGetM(mx_data)<<" "<<mxGetN(mx_data)<<endl;
  assert(mxGetNumberOfElements(mx_data) == 1);
  copy(
    mxGetPr(mx_data),
    mxGetPr(mx_data)+mxGetNumberOfElements(mx_data),
    &d);
  return true;
}

◆ find() [2/4]

template<typename DerivedM >

bool igl::matlab::MatlabWorkspace::find	(	const std::string &	name,
		Eigen::PlainObjectBase< DerivedM > &	M
	)

inline

{
  using namespace std;
  const int i = std::find(names.begin(), names.end(), name)-names.begin();
  if(i>=(int)names.size())
  {
    return false;
  }
  assert(i<=(int)data.size());
  mxArray * mx_data = data[i];
  assert(!mxIsSparse(mx_data));
  assert(mxGetNumberOfDimensions(mx_data) == 2);
  //cout<<name<<": "<<mxGetM(mx_data)<<" "<<mxGetN(mx_data)<<endl;
  const int m = mxGetM(mx_data);
  const int n = mxGetN(mx_data);
  // Handle vectors: in the sense that anything found becomes a column vector,
  // whether it was column vector, row vector or matrix
  if(DerivedM::IsVectorAtCompileTime)
  {
    assert(m==1 || n==1 || (m==0 && n==0));
    M.resize(m*n,1);
  }else
  {
    M.resize(m,n);
  }
  assert(mxGetNumberOfElements(mx_data) == M.size());
  // Use Eigen's map and cast to copy
  M = Eigen::Map< Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic> > 
    (mxGetPr(mx_data),M.rows(),M.cols()).cast<typename DerivedM::Scalar>();
  return true;
}

References Eigen::PlainObjectBase< Derived >::cols(), Eigen::PlainObjectBase< Derived >::resize(), and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function:

◆ find() [3/4]

template<typename MT >

bool igl::matlab::MatlabWorkspace::find	(	const std::string &	name,
		Eigen::SparseMatrix< MT > &	M
	)

inline

{
  using namespace std;
  using namespace Eigen;
  const int i = std::find(names.begin(), names.end(), name)-names.begin();
  if(i>=(int)names.size())
  {
    return false;
  }
  assert(i<=(int)data.size());
  mxArray * mx_data = data[i];
  // Handle boring case where matrix is actually an empty dense matrix
  if(mxGetNumberOfElements(mx_data) == 0)
  {
    M.resize(0,0);
    return true;
  }
  assert(mxIsSparse(mx_data));
  assert(mxGetNumberOfDimensions(mx_data) == 2);
  //cout<<name<<": "<<mxGetM(mx_data)<<" "<<mxGetN(mx_data)<<endl;
  const int m = mxGetM(mx_data);
  const int n = mxGetN(mx_data);
  // TODO: It should be possible to directly load the data into the sparse
  // matrix without going through the triplets
  // Copy data immediately
  double * pr = mxGetPr(mx_data);
  mwIndex * ir = mxGetIr(mx_data);
  mwIndex * jc = mxGetJc(mx_data);
  vector<Triplet<MT> > MIJV;
  const int nnz = mxGetNzmax(mx_data);
  MIJV.reserve(nnz);
  // Iterate over outside
  int k = 0;
  for(int j=0; j<n;j++)
  {
    // Iterate over inside
    while(k<(int)jc[j+1])
    {
      //cout<<ir[k]<<" "<<j<<" "<<pr[k]<<endl;
      assert((int)ir[k]<m);
      assert((int)j<n);
      MIJV.push_back(Triplet<MT >(ir[k],j,pr[k]));
      k++;
    }
  }
  M.resize(m,n);
  M.setFromTriplets(MIJV.begin(),MIJV.end());
 
  return true;
}

References Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::resize(), and Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::setFromTriplets().

Here is the call graph for this function:

◆ find() [4/4]

bool igl::matlab::MatlabWorkspace::find	(	const std::string &	name,
		int &	v
	)

inline

{
  using namespace std;
  const int i = std::find(names.begin(), names.end(), name)-names.begin();
  if(i>=(int)names.size())
  {
    return false;
  }
  assert(i<=(int)data.size());
  mxArray * mx_data = data[i];
  assert(!mxIsSparse(mx_data));
  assert(mxGetNumberOfDimensions(mx_data) == 2);
  //cout<<name<<": "<<mxGetM(mx_data)<<" "<<mxGetN(mx_data)<<endl;
  assert(mxGetNumberOfElements(mx_data) == 1);
  copy(
    mxGetPr(mx_data),
    mxGetPr(mx_data)+mxGetNumberOfElements(mx_data),
    &v);
  return true;
}

◆ find_index()

template<typename DerivedM >

bool igl::matlab::MatlabWorkspace::find_index	(	const std::string &	name,
		Eigen::PlainObjectBase< DerivedM > &	M
	)

inline

{
  if(!find(name,M))
  {
    return false;
  }
  M.array() -= 1;
  return true;
}

References igl::find().

Here is the call graph for this function:

◆ read()

bool igl::matlab::MatlabWorkspace::read ( const std::string & path )

inline

{
  using namespace std;
 
  MATFile * mat_file;
 
  mat_file = matOpen(path.c_str(), "r");
  if (mat_file == NULL) 
  {
    cerr<<"Error: failed to open "<<path<<endl;
    return false;
  }
 
  int ndir;
  const char ** dir = (const char **)matGetDir(mat_file, &ndir);
  if (dir == NULL) {
    cerr<<"Error reading directory of file "<< path<<endl;
    return false;
  }
  mxFree(dir);
 
  // Must close and reopen
  if(matClose(mat_file) != 0)
  {
    cerr<<"Error: failed to close file "<<path<<endl;
    return false;
  }
  mat_file = matOpen(path.c_str(), "r");
  if (mat_file == NULL) 
  {
    cerr<<"Error: failed to open "<<path<<endl;
    return false;
  }
  
 
  /* Read in each array. */
  for (int i=0; i<ndir; i++) 
  {
    const char * name;
    mxArray * mx_data = matGetNextVariable(mat_file, &name);
    if (mx_data == NULL) 
    {
      cerr<<"Error: matGetNextVariable failed in "<<path<<endl;
      return false;
    } 
    const int dims = mxGetNumberOfDimensions(mx_data);
    assert(dims == 2);
    if(dims != 2)
    {
      fprintf(stderr,"Variable '%s' has %d ≠ 2 dimensions. Skipping\n",
          name,dims);
      mxDestroyArray(mx_data);
      continue;
    }
    // don't destroy
    names.push_back(name);
    data.push_back(mx_data);
  }
 
  if(matClose(mat_file) != 0)
  {
    cerr<<"Error: failed to close file "<<path<<endl;
    return false;
  }
 
  return true;
}

◆ save() [1/11]

igl::matlab::MatlabWorkspace & igl::matlab::MatlabWorkspace::save	(	const double	d,
		const std::string &	name
	)

inline

{
  Eigen::VectorXd v(1);
  v(0) = d;
  return save(v,name);
}

References save().

Here is the call graph for this function:

◆ save() [2/11]

template<typename DerivedM >

MatlabWorkspace & igl::matlab::MatlabWorkspace::save	(	const Eigen::PlainObjectBase< DerivedM > &	M,
		const std::string &	name
	)

inline

◆ save() [3/11]

template<typename DerivedM >

igl::matlab::MatlabWorkspace & igl::matlab::MatlabWorkspace::save	(	const Eigen::PlainObjectBase< DerivedM > &	M,
		const std::string &	name
	)

inline

{
  using namespace std;
  const int m = M.rows();
  const int n = M.cols();
  mxArray * mx_data = mxCreateDoubleMatrix(m,n,mxREAL);
  data.push_back(mx_data);
  names.push_back(name);
  // Copy data immediately
  // Use Eigen's map and cast to copy
  Eigen::Map< Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic> > 
    map(mxGetPr(mx_data),m,n);
  map = M.template cast<double>();
  return *this;
}

References Eigen::PlainObjectBase< Derived >::cols(), and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function:

◆ save() [4/11]

template<typename Q >

MatlabWorkspace & igl::matlab::MatlabWorkspace::save	(	const Eigen::Quaternion< Q > &	q,
		const std::string &	name
	)

inline

◆ save() [5/11]

template<typename Q >

igl::matlab::MatlabWorkspace & igl::matlab::MatlabWorkspace::save	(	const Eigen::Quaternion< Q > &	q,
		const std::string &	name
	)

inline

{
  Eigen::Matrix<Q,1,4> qm;
  qm(0,0) = q.w();
  qm(0,1) = q.x();
  qm(0,2) = q.y();
  qm(0,3) = q.z();
  return save(qm,name);
}

References save(), Eigen::QuaternionBase< Derived >::w(), Eigen::QuaternionBase< Derived >::x(), Eigen::QuaternionBase< Derived >::y(), and Eigen::QuaternionBase< Derived >::z().

Here is the call graph for this function:

◆ save() [6/11]

template<typename MT >

MatlabWorkspace & igl::matlab::MatlabWorkspace::save	(	const Eigen::SparseMatrix< MT > &	M,
		const std::string &	name
	)

inline

◆ save() [7/11]

template<typename MT >

igl::matlab::MatlabWorkspace & igl::matlab::MatlabWorkspace::save	(	const Eigen::SparseMatrix< MT > &	M,
		const std::string &	name
	)

inline

{
  using namespace std;
  const int m = M.rows();
  const int n = M.cols();
  // THIS WILL NOT WORK FOR ROW-MAJOR
  assert(n==M.outerSize());
  const int nzmax = M.nonZeros();
  mxArray * mx_data = mxCreateSparse(m, n, nzmax, mxREAL);
  data.push_back(mx_data);
  names.push_back(name);
  // Copy data immediately
  double * pr = mxGetPr(mx_data);
  mwIndex * ir = mxGetIr(mx_data);
  mwIndex * jc = mxGetJc(mx_data);
 
  // Iterate over outside
  int k = 0;
  for(int j=0; j<M.outerSize();j++)
  {
    jc[j] = k;
    // Iterate over inside
    for(typename Eigen::SparseMatrix<MT>::InnerIterator it (M,j); it; ++it)
    {
      pr[k] = it.value();
      ir[k] = it.row();
      k++;
    }
  }
  jc[M.outerSize()] = k;
 
  return *this;
}

References Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::cols(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::nonZeros(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::outerSize(), and Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::rows().

Here is the call graph for this function:

◆ save() [8/11]

template<typename ScalarV >

MatlabWorkspace & igl::matlab::MatlabWorkspace::save	(	const std::vector< ScalarV > &	vV,
		const std::string &	name
	)

inline

◆ save() [9/11]

template<typename ScalarV >

igl::matlab::MatlabWorkspace & igl::matlab::MatlabWorkspace::save	(	const std::vector< ScalarV > &	vV,
		const std::string &	name
	)

inline

{
  Eigen::MatrixXd V;
  list_to_matrix(vV,V);
  return this->save(V,name);
}

References igl::list_to_matrix(), and save().

Here is the call graph for this function:

◆ save() [10/11]

template<typename ScalarM >

MatlabWorkspace & igl::matlab::MatlabWorkspace::save	(	const std::vector< std::vector< ScalarM > > &	vM,
		const std::string &	name
	)

inline

◆ save() [11/11]

template<typename ScalarM >

igl::matlab::MatlabWorkspace & igl::matlab::MatlabWorkspace::save	(	const std::vector< std::vector< ScalarM > > &	vM,
		const std::string &	name
	)

inline

{
  Eigen::MatrixXd M;
  list_to_matrix(vM,M);
  return this->save(M,name);
}

References igl::list_to_matrix(), and save().

Here is the call graph for this function:

◆ save_index() [1/6]

template<typename DerivedM >

MatlabWorkspace & igl::matlab::MatlabWorkspace::save_index	(	const Eigen::DenseBase< DerivedM > &	M,
		const std::string &	name
	)

inline

◆ save_index() [2/6]

template<typename DerivedM >

igl::matlab::MatlabWorkspace & igl::matlab::MatlabWorkspace::save_index	(	const Eigen::DenseBase< DerivedM > &	M,
		const std::string &	name
	)

inline

{
  DerivedM Mp1 = M;
  Mp1.array() += 1;
  return this->save(Mp1,name);
}

References save().

Here is the call graph for this function:

◆ save_index() [3/6]

template<typename ScalarV >

MatlabWorkspace & igl::matlab::MatlabWorkspace::save_index	(	const std::vector< ScalarV > &	vV,
		const std::string &	name
	)

inline

◆ save_index() [4/6]

template<typename ScalarV >

igl::matlab::MatlabWorkspace & igl::matlab::MatlabWorkspace::save_index	(	const std::vector< ScalarV > &	vV,
		const std::string &	name
	)

inline

{
  Eigen::MatrixXd V;
  list_to_matrix(vV,V);
  return this->save_index(V,name);
}

References igl::list_to_matrix().

Here is the call graph for this function:

◆ save_index() [5/6]

template<typename ScalarM >

MatlabWorkspace & igl::matlab::MatlabWorkspace::save_index	(	const std::vector< std::vector< ScalarM > > &	vM,
		const std::string &	name
	)

inline

◆ save_index() [6/6]

template<typename ScalarM >

igl::matlab::MatlabWorkspace & igl::matlab::MatlabWorkspace::save_index	(	const std::vector< std::vector< ScalarM > > &	vM,
		const std::string &	name
	)

inline

{
  Eigen::MatrixXd M;
  list_to_matrix(vM,M);
  return this->save_index(M,name);
}

References igl::list_to_matrix().

Here is the call graph for this function:

◆ write()

bool igl::matlab::MatlabWorkspace::write ( const std::string & path ) const

inline

{
  using namespace std;
  MATFile * mat_file = matOpen(path.c_str(), "w");
  if(mat_file == NULL)
  {
    fprintf(stderr,"Error opening file %s\n",path.c_str());
    return false;
  }
  assert(names.size() == data.size());
  // loop over names and data
  for(int i = 0;i < (int)names.size(); i++)
  {
    // Put variable as LOCAL variable
    int status = matPutVariable(mat_file,names[i].c_str(), data[i]);
    if(status != 0) 
    {
      cerr<<"^MatlabWorkspace::save Error: matPutVariable ("<<names[i]<<
        ") failed"<<endl;
      return false;
    } 
  }
  if(matClose(mat_file) != 0)
  {
    fprintf(stderr,"Error closing file %s\n",path.c_str());
    return false;
  }
  return true;
}

Member Data Documentation

◆ data

std::vector<mxArray*> igl::matlab::MatlabWorkspace::data

private

◆ names

std::vector<std::string> igl::matlab::MatlabWorkspace::names

private

The documentation for this class was generated from the following file:

src/libigl/igl/matlab/MatlabWorkspace.h

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MatlabWorkspace()

◆ ~MatlabWorkspace()

Member Function Documentation

◆ clear()

◆ find() [1/4]

◆ find() [2/4]

◆ find() [3/4]

◆ find() [4/4]

◆ find_index()

◆ read()

◆ save() [1/11]

◆ save() [2/11]

◆ save() [3/11]

◆ save() [4/11]

◆ save() [5/11]

◆ save() [6/11]

◆ save() [7/11]

◆ save() [8/11]

◆ save() [9/11]

◆ save() [10/11]

◆ save() [11/11]

◆ save_index() [1/6]

◆ save_index() [2/6]

◆ save_index() [3/6]

◆ save_index() [4/6]

◆ save_index() [5/6]

◆ save_index() [6/6]

◆ write()

Member Data Documentation

◆ data

◆ names