igl::copyleft::tetgen Namespace Reference

Classes
struct	CDTParam

Functions
template<typename DerivedV , typename DerivedF , typename DerivedTV , typename DerivedTT , typename DerivedTF >
IGL_INLINE bool	cdt (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const CDTParam &param, Eigen::PlainObjectBase< DerivedTV > &TV, Eigen::PlainObjectBase< DerivedTT > &TT, Eigen::PlainObjectBase< DerivedTF > &TF)
IGL_INLINE bool	mesh_to_tetgenio (const std::vector< std::vector< REAL > > &V, const std::vector< std::vector< int > > &F, tetgenio &in)
template<typename DerivedV , typename DerivedF >
IGL_INLINE bool	mesh_to_tetgenio (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, tetgenio &in)
IGL_INLINE bool	mesh_with_skeleton (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, const Eigen::MatrixXd &C, const Eigen::VectorXi &, const Eigen::MatrixXi &BE, const Eigen::MatrixXi &CE, const int samples_per_bone, const std::string &tetgen_flags, Eigen::MatrixXd &VV, Eigen::MatrixXi &TT, Eigen::MatrixXi &FF)
IGL_INLINE bool	mesh_with_skeleton (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, const Eigen::MatrixXd &C, const Eigen::VectorXi &, const Eigen::MatrixXi &BE, const Eigen::MatrixXi &CE, const int samples_per_bone, Eigen::MatrixXd &VV, Eigen::MatrixXi &TT, Eigen::MatrixXi &FF)
IGL_INLINE bool	read_into_tetgenio (const std::string &path, tetgenio &in)
IGL_INLINE bool	tetgenio_to_tetmesh (const tetgenio &out, std::vector< std::vector< REAL > > &V, std::vector< std::vector< int > > &T, std::vector< std::vector< int > > &F)
IGL_INLINE bool	tetgenio_to_tetmesh (const tetgenio &out, std::vector< std::vector< REAL > > &V, std::vector< std::vector< int > > &T)
template<typename DerivedV , typename DerivedT , typename DerivedF >
IGL_INLINE bool	tetgenio_to_tetmesh (const tetgenio &out, Eigen::PlainObjectBase< DerivedV > &V, Eigen::PlainObjectBase< DerivedT > &T, Eigen::PlainObjectBase< DerivedF > &F)
template<typename DerivedV , typename DerivedT >
IGL_INLINE bool	tetgenio_to_tetmesh (const tetgenio &out, Eigen::PlainObjectBase< DerivedV > &V, Eigen::PlainObjectBase< DerivedT > &T)
IGL_INLINE int	tetrahedralize (const std::vector< std::vector< REAL > > &V, const std::vector< std::vector< int > > &F, const std::string switches, std::vector< std::vector< REAL > > &TV, std::vector< std::vector< int > > &TT, std::vector< std::vector< int > > &TF)
template<typename DerivedV , typename DerivedF , typename DerivedTV , typename DerivedTT , typename DerivedTF >
IGL_INLINE int	tetrahedralize (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const std::string switches, Eigen::PlainObjectBase< DerivedTV > &TV, Eigen::PlainObjectBase< DerivedTT > &TT, Eigen::PlainObjectBase< DerivedTF > &TF)
IGL_INLINE int	tetrahedralize (const std::vector< std::vector< REAL > > &V, const std::vector< std::vector< int > > &F, const std::vector< int > &VM, const std::vector< int > &FM, const std::string switches, std::vector< std::vector< REAL > > &TV, std::vector< std::vector< int > > &TT, std::vector< std::vector< int > > &TF, std::vector< int > &TM)
template<typename DerivedV , typename DerivedF , typename DerivedVM , typename DerivedFM , typename DerivedTV , typename DerivedTT , typename DerivedTF , typename DerivedTM >
IGL_INLINE int	tetrahedralize (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, const Eigen::PlainObjectBase< DerivedVM > &VM, const Eigen::PlainObjectBase< DerivedFM > &FM, const std::string switches, Eigen::PlainObjectBase< DerivedTV > &TV, Eigen::PlainObjectBase< DerivedTT > &TT, Eigen::PlainObjectBase< DerivedTF > &TF, Eigen::PlainObjectBase< DerivedTM > &TM)

---

Class Documentation

igl::copyleft::tetgen::CDTParam

struct igl::copyleft::tetgen::CDTParam

Collaboration diagram for igl::copyleft::tetgen::CDTParam:

Class Members
double	bounding_box_scale = 1.01
string	flags = "Y"
bool	use_bounding_box = false

Function Documentation

cdt()

template<typename DerivedV , typename DerivedF , typename DerivedTV , typename DerivedTT , typename DerivedTF >

IGL_INLINE bool igl::copyleft::tetgen::cdt	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const CDTParam &	param,
		Eigen::PlainObjectBase< DerivedTV > &	TV,
		Eigen::PlainObjectBase< DerivedTT > &	TT,
		Eigen::PlainObjectBase< DerivedTF > &	TF
	)

{
  using namespace Eigen;
  using namespace std;
  // Effective input mesh
  DerivedV U;
  DerivedF G;
  if(param.use_bounding_box)
  {
    // Construct bounding box mesh
    DerivedV BV;
    DerivedF BF;
    bounding_box(V,BV,BF);
    // scale bounding box
    const RowVector3d mid = 
     (BV.colwise().minCoeff() + BV.colwise().maxCoeff()).eval()*0.5;
    BV.rowwise() -= mid;
    assert(param.bounding_box_scale >= 1.);
    BV.array() *= param.bounding_box_scale;
    BV.rowwise() += mid;
    // Append bounding box to mesh
    U.resize(V.rows()+BV.rows(),V.cols());
    U<<V,BV;
    BF.array() += V.rows();
    G.resize(F.rows()+BF.rows(),F.cols());
    G<<F,BF;
  }else
  {
    // needless copies
    U = V;
    G = F;
  }
  // effective flags;
  string flags = param.flags + (param.use_bounding_box ? "" : "c");
  return tetrahedralize(U,G,flags,TV,TT,TF);
}

References igl::bounding_box(), igl::copyleft::tetgen::CDTParam::bounding_box_scale, Eigen::PlainObjectBase< Derived >::cols(), igl::copyleft::tetgen::CDTParam::flags, Eigen::PlainObjectBase< Derived >::rows(), tetrahedralize(), and igl::copyleft::tetgen::CDTParam::use_bounding_box.

Here is the call graph for this function:

mesh_to_tetgenio() [1/2]

template<typename DerivedV , typename DerivedF >

IGL_INLINE bool igl::copyleft::tetgen::mesh_to_tetgenio	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		tetgenio &	in
	)

{
  using namespace std;
  vector<vector<REAL> > vV;
  vector<vector<int> > vF;
  matrix_to_list(V,vV);
  matrix_to_list(F,vF);
  return mesh_to_tetgenio(vV,vF,in);
}

References igl::matrix_to_list(), and mesh_to_tetgenio().

Here is the call graph for this function:

mesh_to_tetgenio() [2/2]

IGL_INLINE bool igl::copyleft::tetgen::mesh_to_tetgenio	(	const std::vector< std::vector< REAL > > &	V,
		const std::vector< std::vector< int > > &	F,
		tetgenio &	in
	)

{
  using namespace std;
  // all indices start from 0
  in.firstnumber = 0;
 
  in.numberofpoints = V.size();
  in.pointlist = new REAL[in.numberofpoints * 3];
  // loop over points
  for(int i = 0; i < (int)V.size(); i++)
  {
    assert(V[i].size() == 3);
    in.pointlist[i*3+0] = V[i][0];
    in.pointlist[i*3+1] = V[i][1];
    in.pointlist[i*3+2] = V[i][2];
  }
 
  in.numberoffacets = F.size();
  in.facetlist = new tetgenio::facet[in.numberoffacets];
  in.facetmarkerlist = new int[in.numberoffacets];
 
  // loop over face
  for(int i = 0;i < (int)F.size(); i++)
  {
    in.facetmarkerlist[i] = i;
    tetgenio::facet * f = &in.facetlist[i];
    f->numberofpolygons = 1;
    f->polygonlist = new tetgenio::polygon[f->numberofpolygons];
    f->numberofholes = 0;
    f->holelist = NULL;
    tetgenio::polygon * p = &f->polygonlist[0];
    p->numberofvertices = F[i].size();
    p->vertexlist = new int[p->numberofvertices];
    // loop around face
    for(int j = 0;j < (int)F[i].size(); j++)
    {
      p->vertexlist[j] = F[i][j];
    }
  }
  return true;
}

References REAL.

Referenced by mesh_to_tetgenio(), read_into_tetgenio(), tetrahedralize(), and tetrahedralize().

Here is the caller graph for this function:

mesh_with_skeleton() [1/2]

IGL_INLINE bool igl::copyleft::tetgen::mesh_with_skeleton	(	const Eigen::MatrixXd &	V,
		const Eigen::MatrixXi &	F,
		const Eigen::MatrixXd &	C,
		const Eigen::VectorXi &	,
		const Eigen::MatrixXi &	BE,
		const Eigen::MatrixXi &	CE,
		const int	samples_per_bone,
		const std::string &	tetgen_flags,
		Eigen::MatrixXd &	VV,
		Eigen::MatrixXi &	TT,
		Eigen::MatrixXi &	FF
	)

{
  using namespace Eigen;
  using namespace std;
  const string eff_tetgen_flags = 
    (tetgen_flags.length() == 0?DEFAULT_TETGEN_FLAGS:tetgen_flags);
  // Collect all edges that need samples:
  MatrixXi BECE = cat(1,BE,CE);
  MatrixXd S;
  // Sample each edge with 10 samples. (Choice of 10 doesn't seem to matter so
  // much, but could under some circumstances)
  sample_edges(C,BECE,samples_per_bone,S);
  // Vertices we'll constrain tet mesh to meet
  MatrixXd VS = cat(1,V,S);
  // Use tetgen to mesh the interior of surface, this assumes surface:
  //   * has no holes
  //   * has no non-manifold edges or vertices
  //   * has consistent orientation
  //   * has no self-intersections
  //   * has no 0-volume pieces
  cerr<<"tetgen begin()"<<endl;
  int status = tetrahedralize( VS,F,eff_tetgen_flags,VV,TT,FF);
  cerr<<"tetgen end()"<<endl;
  if(FF.rows() != F.rows())
  {
    // Issue a warning if the surface has changed
    cerr<<"mesh_with_skeleton: Warning: boundary faces != input faces"<<endl;
  }
  if(status != 0)
  {
    cerr<<
      "***************************************************************"<<endl<<
      "***************************************************************"<<endl<<
      "***************************************************************"<<endl<<
      "***************************************************************"<<endl<<
      "* mesh_with_skeleton: tetgen failed. Just meshing convex hull *"<<endl<<
      "***************************************************************"<<endl<<
      "***************************************************************"<<endl<<
      "***************************************************************"<<endl<<
      "***************************************************************"<<endl;
    // If meshing convex hull then use more regular mesh
    status = tetrahedralize(VS,F,"q1.414",VV,TT,FF);
    // I suppose this will fail if the skeleton is outside the mesh
    assert(FF.maxCoeff() < VV.rows());
    if(status != 0)
    {
      cerr<<"mesh_with_skeleton: tetgen failed again."<<endl;
      return false;
    }
  }
 
  return true;
}

References igl::cat(), DEFAULT_TETGEN_FLAGS, igl::sample_edges(), and tetrahedralize().

Referenced by mesh_with_skeleton().

Here is the call graph for this function:

Here is the caller graph for this function:

mesh_with_skeleton() [2/2]

IGL_INLINE bool igl::copyleft::tetgen::mesh_with_skeleton	(	const Eigen::MatrixXd &	V,
		const Eigen::MatrixXi &	F,
		const Eigen::MatrixXd &	C,
		const Eigen::VectorXi &	P,
		const Eigen::MatrixXi &	BE,
		const Eigen::MatrixXi &	CE,
		const int	samples_per_bone,
		Eigen::MatrixXd &	VV,
		Eigen::MatrixXi &	TT,
		Eigen::MatrixXi &	FF
	)

{
  return mesh_with_skeleton(
    V,F,C,P,BE,CE,samples_per_bone,DEFAULT_TETGEN_FLAGS,VV,TT,FF);
}

References DEFAULT_TETGEN_FLAGS, and mesh_with_skeleton().

Here is the call graph for this function:

read_into_tetgenio()

IGL_INLINE bool igl::copyleft::tetgen::read_into_tetgenio	(	const std::string &	path,
		tetgenio &	in
	)

{
  using namespace std;
  // get file extension
  string dirname,basename,ext,filename;
  pathinfo(path,dirname,basename,ext,filename);
  // convert to lower case for easy comparison
  transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
  bool success = false;
 
  char basename_char[1024];
  strcpy(basename_char,basename.c_str());
 
  if(ext == "obj")
  {
    // read obj into vertex list and face list
    vector<vector<REAL> > V,TC,N;
    vector<vector<int>  > F,FTC,FN;
    success = readOBJ(path,V,TC,N,F,FTC,FN);
    success &= mesh_to_tetgenio(V,F,in);
  }else if(ext == "off")
  {
    success = in.load_off(basename_char);
  }else if(ext == "node")
  {
    success = in.load_node(basename_char);
  }else 
  {
    if(ext.length() > 0)
    {
      cerr<<"^read_into_tetgenio Warning: Unsupported extension ("<<ext<<
        "): try to load as basename..."<<endl;
    }
    // This changed as of (the so far unreleased) tetgen 1.5
    //success = in.load_tetmesh(basename_char);
    //int object = tetgenbehavior::NODES;
    //if(ext == "mesh")
    //{
    //  object = tetgenbehavior::MEDIT;
    //}
    success = in.load_tetmesh(basename_char,!tetgenbehavior::MEDIT);
  }
 
  return success;
}

References igl::basename(), igl::dirname(), mesh_to_tetgenio(), igl::pathinfo(), and igl::readOBJ().

Here is the call graph for this function:

tetgenio_to_tetmesh() [1/4]

template<typename DerivedV , typename DerivedT >

IGL_INLINE bool igl::copyleft::tetgen::tetgenio_to_tetmesh	(	const tetgenio &	out,
		Eigen::PlainObjectBase< DerivedV > &	V,
		Eigen::PlainObjectBase< DerivedT > &	T
	)

{
  Eigen::Matrix<typename DerivedT::Scalar,Eigen::Dynamic,3> F;
  return tetgenio_to_tetmesh(out,V,T,F);
}

References tetgenio_to_tetmesh().

Here is the call graph for this function:

tetgenio_to_tetmesh() [2/4]

template<typename DerivedV , typename DerivedT , typename DerivedF >

IGL_INLINE bool igl::copyleft::tetgen::tetgenio_to_tetmesh	(	const tetgenio &	out,
		Eigen::PlainObjectBase< DerivedV > &	V,
		Eigen::PlainObjectBase< DerivedT > &	T,
		Eigen::PlainObjectBase< DerivedF > &	F
	)

{
  using namespace std;
  vector<vector<REAL> > vV;
  vector<vector<int> > vT;
  vector<vector<int> > vF;
  bool success = tetgenio_to_tetmesh(out,vV,vT,vF);
  if(!success)
  {
    return false;
  }
  bool V_rect = list_to_matrix(vV,V);
  if(!V_rect)
  {
    // igl::list_to_matrix(vV,V) already printed error message to std err
    return false;
  }
  bool T_rect = list_to_matrix(vT,T);
  if(!T_rect)
  {
    // igl::list_to_matrix(vT,T) already printed error message to std err
    return false;
  }
  bool F_rect = list_to_matrix(vF,F);
  if(!F_rect)
  {
    return false;
  }
 
  return true;
}

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

Here is the call graph for this function:

tetgenio_to_tetmesh() [3/4]

IGL_INLINE bool igl::copyleft::tetgen::tetgenio_to_tetmesh	(	const tetgenio &	out,
		std::vector< std::vector< REAL > > &	V,
		std::vector< std::vector< int > > &	T
	)

{
  std::vector<std::vector<int> > F;
  return tetgenio_to_tetmesh(out,V,T,F);
}

References tetgenio_to_tetmesh().

Here is the call graph for this function:

tetgenio_to_tetmesh() [4/4]

IGL_INLINE bool igl::copyleft::tetgen::tetgenio_to_tetmesh	(	const tetgenio &	out,
		std::vector< std::vector< REAL > > &	V,
		std::vector< std::vector< int > > &	T,
		std::vector< std::vector< int > > &	F
	)

{
  using namespace std;
  // process points
  if(out.pointlist == NULL)
  {
    cerr<<"^tetgenio_to_tetmesh Error: point list is NULL\n"<<endl;
    return false;
  }
  V.resize(out.numberofpoints,vector<REAL>(3));
  // loop over points
  for(int i = 0;i < out.numberofpoints; i++)
  {
    V[i][0] = out.pointlist[i*3+0];
    V[i][1] = out.pointlist[i*3+1];
    V[i][2] = out.pointlist[i*3+2];
  }
 
 
  // process tets
  if(out.tetrahedronlist == NULL)
  {
    cerr<<"^tetgenio_to_tetmesh Error: tet list is NULL\n"<<endl;
    return false;
  }
 
  // When would this not be 4?
  assert(out.numberofcorners == 4);
  T.resize(out.numberoftetrahedra,vector<int>(out.numberofcorners));
  int min_index = 1e7;
  int max_index = -1e7;
  // loop over tetrahedra
  for(int i = 0; i < out.numberoftetrahedra; i++)
  {
    for(int j = 0; j<out.numberofcorners; j++)
    {
      int index = out.tetrahedronlist[i * out.numberofcorners + j];
      T[i][j] = index;
      min_index = (min_index > index ? index : min_index);
      max_index = (max_index < index ? index : max_index);
    }
  }
  assert(min_index >= 0);
  assert(max_index >= 0);
  assert(max_index < (int)V.size());
 
  cout<<out.numberoftrifaces<<endl;
 
  // When would this not be 4?
  F.clear();
  // loop over tetrahedra
  for(int i = 0; i < out.numberoftrifaces; i++)
  {
    if(out.trifacemarkerlist[i]>=0)
    {
      vector<int> face(3);
      for(int j = 0; j<3; j++)
      {
        face[j] = out.trifacelist[i * 3 + j];
      }
      F.push_back(face);
    }
  }
 
  return true;
}

Referenced by tetgenio_to_tetmesh(), tetgenio_to_tetmesh(), tetgenio_to_tetmesh(), tetrahedralize(), and tetrahedralize().

Here is the caller graph for this function:

tetrahedralize() [1/4]

template<typename DerivedV , typename DerivedF , typename DerivedVM , typename DerivedFM , typename DerivedTV , typename DerivedTT , typename DerivedTF , typename DerivedTM >

IGL_INLINE int igl::copyleft::tetgen::tetrahedralize	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const Eigen::PlainObjectBase< DerivedVM > &	VM,
		const Eigen::PlainObjectBase< DerivedFM > &	FM,
		const std::string	switches,
		Eigen::PlainObjectBase< DerivedTV > &	TV,
		Eigen::PlainObjectBase< DerivedTT > &	TT,
		Eigen::PlainObjectBase< DerivedTF > &	TF,
		Eigen::PlainObjectBase< DerivedTM > &	TM
	)

{
  using namespace std;
  vector<vector<REAL> > vV,vTV;
  vector<vector<int> > vF,vTT,vTF;
  vector<int> vTM;
  
  matrix_to_list(V,vV);
  matrix_to_list(F,vF);
  vector<int> vVM = matrix_to_list(VM);
  vector<int> vFM = matrix_to_list(FM);
  int e = tetrahedralize(vV,vF,vVM,vFM,switches,vTV,vTT,vTF,vTM);
  if(e == 0)
  {
    bool TV_rect = list_to_matrix(vTV,TV);
    if(!TV_rect)
    {
      return false;
    }
    bool TT_rect = list_to_matrix(vTT,TT);
    if(!TT_rect)
    {
      return false;
    }
    bool TF_rect = list_to_matrix(vTF,TF);
    if(!TF_rect)
    {
      return false;
    }
    bool TM_rect = list_to_matrix(vTM,TM);
    if(!TM_rect)
    {
      return false;
    }
  }
  return e;
}

References igl::list_to_matrix(), igl::matrix_to_list(), and tetrahedralize().

Here is the call graph for this function:

tetrahedralize() [2/4]

template<typename DerivedV , typename DerivedF , typename DerivedTV , typename DerivedTT , typename DerivedTF >

IGL_INLINE int igl::copyleft::tetgen::tetrahedralize	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		const std::string	switches,
		Eigen::PlainObjectBase< DerivedTV > &	TV,
		Eigen::PlainObjectBase< DerivedTT > &	TT,
		Eigen::PlainObjectBase< DerivedTF > &	TF
	)

{
  using namespace std;
  vector<vector<REAL> > vV,vTV;
  vector<vector<int> > vF,vTT,vTF;
  matrix_to_list(V,vV);
  matrix_to_list(F,vF);
  int e = tetrahedralize(vV,vF,switches,vTV,vTT,vTF);
  if(e == 0)
  {
    bool TV_rect = list_to_matrix(vTV,TV);
    if(!TV_rect)
    {
      return 3;
    }
    bool TT_rect = list_to_matrix(vTT,TT);
    if(!TT_rect)
    {
      return 3;
    }
    bool TF_rect = list_to_matrix(vTF,TF);
    if(!TF_rect)
    {
      return 3;
    }
  }
  return e;
}

References igl::list_to_matrix(), igl::matrix_to_list(), and tetrahedralize().

Here is the call graph for this function:

tetrahedralize() [3/4]

IGL_INLINE int igl::copyleft::tetgen::tetrahedralize	(	const std::vector< std::vector< REAL > > &	V,
		const std::vector< std::vector< int > > &	F,
		const std::string	switches,
		std::vector< std::vector< REAL > > &	TV,
		std::vector< std::vector< int > > &	TT,
		std::vector< std::vector< int > > &	TF
	)

{
  using namespace std;
  tetgenio in,out;
  bool success;
  success = mesh_to_tetgenio(V,F,in);
  if(!success)
  {
    return -1;
  }
  try
  {
    char * cswitches = new char[switches.size() + 1];
    std::strcpy(cswitches,switches.c_str());
    ::tetrahedralize(cswitches,&in, &out);
    delete[] cswitches;
  }catch(int e)
  {
    cerr<<"^"<<__FUNCTION__<<": TETGEN CRASHED... KABOOOM!!!"<<endl;
    return 1;
  }
  if(out.numberoftetrahedra == 0)
  {
    cerr<<"^"<<__FUNCTION__<<": Tetgen failed to create tets"<<endl;
    return 2;
  }
  success = tetgenio_to_tetmesh(out,TV,TT,TF);
  if(!success)
  {
    return -1;
  }
  //boundary_facets(TT,TF);
  return 0;
}

References mesh_to_tetgenio(), and tetgenio_to_tetmesh().

Referenced by cdt(), mesh_with_skeleton(), tetrahedralize(), and tetrahedralize().

Here is the call graph for this function:

Here is the caller graph for this function:

tetrahedralize() [4/4]

IGL_INLINE int igl::copyleft::tetgen::tetrahedralize	(	const std::vector< std::vector< REAL > > &	V,
		const std::vector< std::vector< int > > &	F,
		const std::vector< int > &	VM,
		const std::vector< int > &	FM,
		const std::string	switches,
		std::vector< std::vector< REAL > > &	TV,
		std::vector< std::vector< int > > &	TT,
		std::vector< std::vector< int > > &	TF,
		std::vector< int > &	TM
	)

{
  using namespace std;
  tetgenio in,out;
  bool success;
  success = mesh_to_tetgenio(V,F,in);
  if(!success)
  {
    return -1;
  }
  in.pointmarkerlist = new int[VM.size()];
  for (int i = 0; i < VM.size(); ++i) {
    in.pointmarkerlist[i] = VM[i];
  }
  // These have already been created in mesh_to_tetgenio.
  // Reset them here.
  for (int i = 0; i < FM.size(); ++i) {
    in.facetmarkerlist[i] = FM[i];
  }
  try
  {
    char * cswitches = new char[switches.size() + 1];
    std::strcpy(cswitches,switches.c_str());
    ::tetrahedralize(cswitches,&in, &out);
    delete[] cswitches;
  }catch(int e)
  {
    cerr<<"^"<<__FUNCTION__<<": TETGEN CRASHED... KABOOOM!!!"<<endl;
    return 1;
  }
  if(out.numberoftetrahedra == 0)
  {
    cerr<<"^"<<__FUNCTION__<<": Tetgen failed to create tets"<<endl;
    return 2;
  }
  success = tetgenio_to_tetmesh(out,TV,TT,TF);
  if(!success)
  {
    return -1;
  }
  TM.resize(out.numberofpoints);
  for (int i = 0; i < out.numberofpoints; ++i) {
    TM[i] = out.pointmarkerlist[i];
  }
  //boundary_facets(TT,TF);
  return 0;
}

References mesh_to_tetgenio(), and tetgenio_to_tetmesh().

Here is the call graph for this function: