igl::matlab Namespace Reference

Classes
class	MatlabWorkspace
class	MexStream

Functions
IGL_INLINE void	mlinit (Engine **engine)
IGL_INLINE void	mlclose (Engine **engine)
IGL_INLINE void	mlsetmatrix (Engine **engine, std::string name, const Eigen::MatrixXd &M)
IGL_INLINE void	mlsetmatrix (Engine **engine, std::string name, const Eigen::MatrixXf &M)
IGL_INLINE void	mlsetmatrix (Engine **engine, std::string name, const Eigen::MatrixXi &M)
IGL_INLINE void	mlsetmatrix (Engine **mlengine, std::string name, const Eigen::Matrix< unsigned int, Eigen::Dynamic, Eigen::Dynamic > &M)
IGL_INLINE void	mlgetmatrix (Engine **engine, std::string name, Eigen::MatrixXd &M)
IGL_INLINE void	mlgetmatrix (Engine **engine, std::string name, Eigen::MatrixXf &M)
IGL_INLINE void	mlgetmatrix (Engine **engine, std::string name, Eigen::MatrixXi &M)
IGL_INLINE void	mlgetmatrix (Engine **mlengine, std::string name, Eigen::Matrix< unsigned int, Eigen::Dynamic, Eigen::Dynamic > &M)
IGL_INLINE void	mlsetscalar (Engine **engine, std::string name, double s)
IGL_INLINE double	mlgetscalar (Engine **engine, std::string name)
IGL_INLINE std::string	mleval (Engine **engine, std::string code)
IGL_INLINE void	mlsetmatrix (Engine **mlengine, std::string name, const Eigen::SparseMatrix< double > &M)
IGL_INLINE void	mexErrMsgTxt (bool test, const char *message)
template<typename DerivedV >
IGL_INLINE void	parse_rhs_double (const mxArray *prhs[], Eigen::PlainObjectBase< DerivedV > &V)
template<typename DerivedV >
IGL_INLINE void	parse_rhs_index (const mxArray *prhs[], Eigen::PlainObjectBase< DerivedV > &V)
template<typename VType >
IGL_INLINE void	parse_rhs (const mxArray *prhs[], Eigen::SparseMatrix< VType > &M)
template<typename DerivedV >
IGL_INLINE void	prepare_lhs_double (const Eigen::PlainObjectBase< DerivedV > &V, mxArray *plhs[])
template<typename DerivedV >
IGL_INLINE void	prepare_lhs_logical (const Eigen::PlainObjectBase< DerivedV > &V, mxArray *plhs[])
template<typename DerivedV >
IGL_INLINE void	prepare_lhs_index (const Eigen::PlainObjectBase< DerivedV > &V, mxArray *plhs[])
template<typename Vtype >
IGL_INLINE void	prepare_lhs_double (const Eigen::SparseMatrix< Vtype > &V, mxArray *plhs[])
IGL_INLINE void	requires_arg (const int i, const int nrhs, const char *name)
IGL_INLINE void	validate_arg_scalar (const int i, const int nrhs, const mxArray *prhs[], const char *name)
IGL_INLINE void	validate_arg_logical (const int i, const int nrhs, const mxArray *prhs[], const char *name)
IGL_INLINE void	validate_arg_char (const int i, const int nrhs, const mxArray *prhs[], const char *name)
IGL_INLINE void	validate_arg_double (const int i, const int nrhs, const mxArray *prhs[], const char *name)
IGL_INLINE void	validate_arg_function_handle (const int i, const int nrhs, const mxArray *prhs[], const char *name)

Function Documentation

mexErrMsgTxt()

IGL_INLINE void igl::matlab::mexErrMsgTxt	(	bool	test,
		const char *	message
	)

{
  if(!assertion)
  {
    ::mexErrMsgTxt(text);
  }
}

Referenced by requires_arg(), validate_arg_char(), validate_arg_double(), validate_arg_function_handle(), validate_arg_logical(), and validate_arg_scalar().

Here is the caller graph for this function:

mlclose()

IGL_INLINE void igl::matlab::mlclose

(

Engine **

engine

)

{
  engClose(*mlengine);
  *mlengine = 0;
}

mleval()

IGL_INLINE std::string igl::matlab::mleval	(	Engine **	engine,
		std::string	code
	)

{
  if (*mlengine == 0)
    mlinit(mlengine);
 
  const char *matlab_code = code.c_str();
  const int BUF_SIZE = 4096*4096;
  // allocate on the heap to avoid running out of stack
  std::string bufauto(BUF_SIZE+1, '\0');
  char *buf = &bufauto[0];
 
  assert(matlab_code != NULL);
 
  // Use RAII ensure that on leaving this scope, the output buffer is
  // always nullified (to prevent Matlab from accessing memory that might
  // have already been deallocated).
  struct cleanup {
    Engine *m_ep;
    cleanup(Engine *ep) : m_ep(ep) { }
    ~cleanup() { engOutputBuffer(m_ep, NULL, 0); }
  } cleanup_obj(*mlengine);
 
  if (buf != NULL)
    engOutputBuffer(*mlengine, buf, BUF_SIZE);
 
  int res = engEvalString(*mlengine, matlab_code);
 
  if (res != 0) {
    std::ostringstream oss;
    oss << "ERROR: Matlab command failed with error code " << res << ".\n";
    return oss.str();
  }
 
  if (buf[0] == '>' && buf[1] == '>' && buf[2] == ' ')
    buf += 3;
  if (buf[0] == '\n') ++buf;
 
  return std::string(buf);
}

References mlinit().

Referenced by mlsetmatrix().

Here is the call graph for this function:

Here is the caller graph for this function:

mlgetmatrix() [1/4]

IGL_INLINE void igl::matlab::mlgetmatrix	(	Engine **	engine,
		std::string	name,
		Eigen::MatrixXd &	M
	)

{
  if (*mlengine == 0)
    mlinit(mlengine);
 
  unsigned long m = 0;
  unsigned long n = 0;
  std::vector<double> t;
 
  mxArray *ary = engGetVariable(*mlengine, name.c_str());
  if (ary == NULL)
  {
    m = 0;
    n = 0;
    M = Eigen::MatrixXd(0,0);
  }
  else
  {
    m = mxGetM(ary);
    n = mxGetN(ary);
    M = Eigen::MatrixXd(m,n);
 
    double *pM = mxGetPr(ary);
 
    int c = 0;
    for(int j=0; j<M.cols();++j)
      for(int i=0; i<M.rows();++i)
        M(i,j) = pM[c++];
  }
 
  mxDestroyArray(ary);
}

References mlinit().

Referenced by mlgetscalar().

Here is the call graph for this function:

Here is the caller graph for this function:

mlgetmatrix() [2/4]

IGL_INLINE void igl::matlab::mlgetmatrix	(	Engine **	engine,
		std::string	name,
		Eigen::MatrixXf &	M
	)

{
  if (*mlengine == 0)
    mlinit(mlengine);
 
  unsigned long m = 0;
  unsigned long n = 0;
  std::vector<double> t;
 
  mxArray *ary = engGetVariable(*mlengine, name.c_str());
  if (ary == NULL)
  {
    m = 0;
    n = 0;
    M = Eigen::MatrixXf(0,0);
  }
  else
  {
    m = mxGetM(ary);
    n = mxGetN(ary);
    M = Eigen::MatrixXf(m,n);
 
    double *pM = mxGetPr(ary);
 
    int c = 0;
    for(int j=0; j<M.cols();++j)
      for(int i=0; i<M.rows();++i)
        M(i,j) = pM[c++];
  }
 
  mxDestroyArray(ary);
}

References mlinit().

Here is the call graph for this function:

mlgetmatrix() [3/4]

IGL_INLINE void igl::matlab::mlgetmatrix	(	Engine **	engine,
		std::string	name,
		Eigen::MatrixXi &	M
	)

{
  if (*mlengine == 0)
    mlinit(mlengine);
 
  unsigned long m = 0;
  unsigned long n = 0;
  std::vector<double> t;
 
  mxArray *ary = engGetVariable(*mlengine, name.c_str());
  if (ary == NULL)
  {
    m = 0;
    n = 0;
    M = Eigen::MatrixXi(0,0);
  }
  else
  {
    m = mxGetM(ary);
    n = mxGetN(ary);
    M = Eigen::MatrixXi(m,n);
 
    double *pM = mxGetPr(ary);
 
    int c = 0;
    for(int j=0; j<M.cols();++j)
      for(int i=0; i<M.rows();++i)
        M(i,j) = int(pM[c++])-1;
  }
 
  mxDestroyArray(ary);
}

References mlinit().

Here is the call graph for this function:

mlgetmatrix() [4/4]

IGL_INLINE void igl::matlab::mlgetmatrix	(	Engine **	mlengine,
		std::string	name,
		Eigen::Matrix< unsigned int, Eigen::Dynamic, Eigen::Dynamic > &	M
	)

{
  if (*mlengine == 0)
    mlinit(mlengine);
 
  unsigned long m = 0;
  unsigned long n = 0;
  std::vector<double> t;
 
  mxArray *ary = engGetVariable(*mlengine, name.c_str());
  if (ary == NULL)
  {
    m = 0;
    n = 0;
    M = Eigen::Matrix<unsigned int, Eigen::Dynamic, Eigen::Dynamic >(0,0);
  }
  else
  {
    m = mxGetM(ary);
    n = mxGetN(ary);
    M = Eigen::Matrix<unsigned int, Eigen::Dynamic, Eigen::Dynamic >(m,n);
 
    double *pM = mxGetPr(ary);
 
    int c = 0;
    for(int j=0; j<M.cols();++j)
      for(int i=0; i<M.rows();++i)
        M(i,j) = (unsigned int)(pM[c++])-1;
  }
 
  mxDestroyArray(ary);
}

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

Here is the call graph for this function:

mlgetscalar()

IGL_INLINE double igl::matlab::mlgetscalar	(	Engine **	engine,
		std::string	name
	)

{
  if (*mlengine == 0)
    mlinit(mlengine);
 
  Eigen::MatrixXd M;
  mlgetmatrix(mlengine, name,M);
  return M(0,0);
}

References mlgetmatrix(), and mlinit().

Here is the call graph for this function:

mlinit()

IGL_INLINE void igl::matlab::mlinit

(

Engine **

engine

)

{
  *mlengine = engOpen("\0");
}

Referenced by mleval(), mlgetmatrix(), mlgetmatrix(), mlgetmatrix(), mlgetmatrix(), mlgetscalar(), mlsetmatrix(), mlsetmatrix(), mlsetmatrix(), mlsetmatrix(), and mlsetscalar().

Here is the caller graph for this function:

mlsetmatrix() [1/5]

IGL_INLINE void igl::matlab::mlsetmatrix	(	Engine **	engine,
		std::string	name,
		const Eigen::MatrixXd &	M
	)

{
  if (*mlengine == 0)
    mlinit(mlengine);
 
  mxArray *A = mxCreateDoubleMatrix(M.rows(), M.cols(), mxREAL);
  double *pM = mxGetPr(A);
 
  int c = 0;
  for(int j=0; j<M.cols();++j)
    for(int i=0; i<M.rows();++i)
      pM[c++] = double(M(i,j));
 
  engPutVariable(*mlengine, name.c_str(), A);
  mxDestroyArray(A);
}

References mlinit().

Referenced by mlsetmatrix(), and mlsetscalar().

Here is the call graph for this function:

Here is the caller graph for this function:

mlsetmatrix() [2/5]

IGL_INLINE void igl::matlab::mlsetmatrix	(	Engine **	engine,
		std::string	name,
		const Eigen::MatrixXf &	M
	)

{
  if (*mlengine == 0)
    mlinit(mlengine);
 
  mxArray *A = mxCreateDoubleMatrix(M.rows(), M.cols(), mxREAL);
  double *pM = mxGetPr(A);
 
  int c = 0;
  for(int j=0; j<M.cols();++j)
    for(int i=0; i<M.rows();++i)
      pM[c++] = double(M(i,j));
 
  engPutVariable(*mlengine, name.c_str(), A);
  mxDestroyArray(A);
}

References mlinit().

Here is the call graph for this function:

mlsetmatrix() [3/5]

IGL_INLINE void igl::matlab::mlsetmatrix	(	Engine **	engine,
		std::string	name,
		const Eigen::MatrixXi &	M
	)

{
  if (*mlengine == 0)
    mlinit(mlengine);
 
  mxArray *A = mxCreateDoubleMatrix(M.rows(), M.cols(), mxREAL);
  double *pM = mxGetPr(A);
 
  int c = 0;
  for(int j=0; j<M.cols();++j)
    for(int i=0; i<M.rows();++i)
      pM[c++] = double(M(i,j))+1;
 
  engPutVariable(*mlengine, name.c_str(), A);
  mxDestroyArray(A);
}

References mlinit().

Here is the call graph for this function:

mlsetmatrix() [4/5]

IGL_INLINE void igl::matlab::mlsetmatrix	(	Engine **	mlengine,
		std::string	name,
		const Eigen::Matrix< unsigned int, Eigen::Dynamic, Eigen::Dynamic > &	M
	)

{
  if (*mlengine == 0)
    mlinit(mlengine);
 
  mxArray *A = mxCreateDoubleMatrix(M.rows(), M.cols(), mxREAL);
  double *pM = mxGetPr(A);
 
  int c = 0;
  for(int j=0; j<M.cols();++j)
    for(int i=0; i<M.rows();++i)
      pM[c++] = double(M(i,j))+1;
 
  engPutVariable(*mlengine, name.c_str(), A);
  mxDestroyArray(A);
}

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

Here is the call graph for this function:

mlsetmatrix() [5/5]

IGL_INLINE void igl::matlab::mlsetmatrix	(	Engine **	mlengine,
		std::string	name,
		const Eigen::SparseMatrix< double > &	M
	)

{
  int count = 0;
//  // Count non-zero
//  for (unsigned k=0; k<M.outerSize(); ++k)
//    for (Eigen::SparseMatrix<double>::InnerIterator it(M,k); it; ++it)
//      if (it.value() != 0)
//        ++count;
  
  Eigen::MatrixXd T(M.nonZeros(),3);
  for (unsigned k=0; k<(unsigned)M.outerSize(); ++k)
  {
    for (Eigen::SparseMatrix<double>::InnerIterator it(M,k); it; ++it)
    {
      T(count,0) = it.row();
      T(count,1) = it.col();
      T(count,2) = it.value();
      ++count;
    }
  }
 
  T.col(0) = T.col(0).array()+1;
  T.col(1) = T.col(1).array()+1;
 
  mlsetmatrix(mlengine,"temp93765",T);
  
  std::string temp = name + " = sparse(temp93765(:,1),temp93765(:,2),temp93765(:,3),"
                          + std::to_string(M.rows()) + ","
                          + std::to_string(M.cols()) + ");";
  
  mleval(mlengine,temp);
  mleval(mlengine,"clear temp93765");
}

References Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::cols(), igl::count(), mleval(), mlsetmatrix(), 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:

mlsetscalar()

IGL_INLINE void igl::matlab::mlsetscalar	(	Engine **	engine,
		std::string	name,
		double	s
	)

{
  if (*mlengine == 0)
    mlinit(mlengine);
 
  Eigen::MatrixXd M(1,1);
  M(0,0) = s;
  mlsetmatrix(mlengine, name, M);
}

References mlinit(), and mlsetmatrix().

Here is the call graph for this function:

parse_rhs()

template<typename VType >

IGL_INLINE void igl::matlab::parse_rhs	(	const mxArray *	prhs[],
		Eigen::SparseMatrix< VType > &	M
	)

parse_rhs_double()

template<typename DerivedV >

IGL_INLINE void igl::matlab::parse_rhs_double	(	const mxArray *	prhs[],
		Eigen::PlainObjectBase< DerivedV > &	V
	)

{
  using namespace Eigen;
  // Use Eigen's map and cast to copy
  V = Map< Matrix<double,Dynamic,Dynamic> >
    (mxGetPr(prhs[0]),mxGetM(prhs[0]),mxGetN(prhs[0]))
    .cast<typename DerivedV::Scalar>();
}

Referenced by parse_rhs_index().

Here is the caller graph for this function:

parse_rhs_index()

template<typename DerivedV >

IGL_INLINE void igl::matlab::parse_rhs_index	(	const mxArray *	prhs[],
		Eigen::PlainObjectBase< DerivedV > &	V
	)

{
  parse_rhs_double(prhs,V);
  V.array() -= 1;
}

References parse_rhs_double().

Here is the call graph for this function:

prepare_lhs_double() [1/2]

template<typename DerivedV >

IGL_INLINE void igl::matlab::prepare_lhs_double	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		mxArray *	plhs[]
	)

{
  using namespace std;
  using namespace Eigen;
  const int m = V.rows();
  const int n = V.cols();
  plhs[0] = mxCreateDoubleMatrix(m,n, mxREAL);
  Eigen::Map< Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic> > 
    map(mxGetPr(plhs[0]),m,n);
  map = V.template cast<double>();
}

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

Referenced by prepare_lhs_index().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_lhs_double() [2/2]

template<typename Vtype >

IGL_INLINE void igl::matlab::prepare_lhs_double	(	const Eigen::SparseMatrix< Vtype > &	V,
		mxArray *	plhs[]
	)

{
  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();
  plhs[0] = mxCreateSparse(m, n, nzmax, mxREAL);
  mxArray * mx_data = plhs[0];
  // 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<Vtype>::InnerIterator it (M,j); it; ++it)
    {
      // copy (cast to double)
      pr[k] = it.value();
      ir[k] = it.row();
      k++;
    }
  }
  jc[M.outerSize()] = k;
 
}

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:

prepare_lhs_index()

template<typename DerivedV >

IGL_INLINE void igl::matlab::prepare_lhs_index	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		mxArray *	plhs[]
	)

{
  // Treat indices as reals
  const auto Vd = (V.template cast<double>().array()+1).eval();
  return prepare_lhs_double(Vd,plhs);
}

References prepare_lhs_double().

Here is the call graph for this function:

prepare_lhs_logical()

template<typename DerivedV >

IGL_INLINE void igl::matlab::prepare_lhs_logical	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		mxArray *	plhs[]
	)

{
  using namespace std;
  using namespace Eigen;
  const int m = V.rows();
  const int n = V.cols();
  plhs[0] = mxCreateLogicalMatrix(m,n);
  mxLogical * Vp = static_cast<mxLogical*>(mxGetData(plhs[0]));
  Eigen::Map< Eigen::Matrix<mxLogical,Eigen::Dynamic,Eigen::Dynamic> > 
    map(static_cast<mxLogical*>(mxGetData(plhs[0])),m,n);
  map = V.template cast<mxLogical>();
}

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

Here is the call graph for this function:

requires_arg()

IGL_INLINE void igl::matlab::requires_arg	(	const int	i,
		const int	nrhs,
		const char *	name
	)

{
  mexErrMsgTxt((i+1)<nrhs,
      C_STR("Parameter '"<<name<<"' requires argument"));
}

References C_STR, and mexErrMsgTxt().

Referenced by validate_arg_char(), validate_arg_double(), validate_arg_function_handle(), validate_arg_logical(), and validate_arg_scalar().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_arg_char()

IGL_INLINE void igl::matlab::validate_arg_char	(	const int	i,
		const int	nrhs,
		const mxArray *	prhs[],
		const char *	name
	)

{
  requires_arg(i,nrhs,name);
  mexErrMsgTxt(mxIsChar(prhs[i+1]),
    C_STR("Parameter '"<<name<<"' requires char argument"));
}

References C_STR, mexErrMsgTxt(), and requires_arg().

Here is the call graph for this function:

validate_arg_double()

IGL_INLINE void igl::matlab::validate_arg_double	(	const int	i,
		const int	nrhs,
		const mxArray *	prhs[],
		const char *	name
	)

{
  requires_arg(i,nrhs,name);
  mexErrMsgTxt(mxIsDouble(prhs[i+1]),
    C_STR("Parameter '"<<name<<"' requires double argument"));
}

References C_STR, mexErrMsgTxt(), and requires_arg().

Here is the call graph for this function:

validate_arg_function_handle()

IGL_INLINE void igl::matlab::validate_arg_function_handle	(	const int	i,
		const int	nrhs,
		const mxArray *	prhs[],
		const char *	name
	)

{
  requires_arg(i,nrhs,name);
  mexErrMsgTxt(mxIsClass(prhs[i+1],"function_handle"),
    C_STR("Parameter '"<<name<<"' requires function handle argument"));
}

References C_STR, mexErrMsgTxt(), and requires_arg().

Here is the call graph for this function:

validate_arg_logical()

IGL_INLINE void igl::matlab::validate_arg_logical	(	const int	i,
		const int	nrhs,
		const mxArray *	prhs[],
		const char *	name
	)

{
  requires_arg(i,nrhs,name);
  mexErrMsgTxt(mxIsLogical(prhs[i+1]),
    C_STR("Parameter '"<<name<<"' requires Logical argument"));
}

References C_STR, mexErrMsgTxt(), and requires_arg().

Here is the call graph for this function:

validate_arg_scalar()

IGL_INLINE void igl::matlab::validate_arg_scalar	(	const int	i,
		const int	nrhs,
		const mxArray *	prhs[],
		const char *	name
	)

{
  requires_arg(i,nrhs,name);
  mexErrMsgTxt(mxGetN(prhs[i+1])==1 && mxGetM(prhs[i+1])==1,
      C_STR("Parameter '"<<name<<"' requires scalar argument"));
}

References C_STR, mexErrMsgTxt(), and requires_arg().

Here is the call graph for this function: