igl::triangle Namespace Reference

Functions
template<typename DerivedV , typename DerivedE , typename DerivedWV , typename DerivedWF , typename DerivedWE , typename DerivedJ >
IGL_INLINE void	cdt (const Eigen::MatrixBase< DerivedV > &V, const Eigen::MatrixBase< DerivedE > &E, const std::string &flags, Eigen::PlainObjectBase< DerivedWV > &WV, Eigen::PlainObjectBase< DerivedWF > &WF, Eigen::PlainObjectBase< DerivedWE > &WE, Eigen::PlainObjectBase< DerivedJ > &J)
template<typename DerivedV , typename DerivedE , typename DerivedH , typename DerivedV2 , typename DerivedF2 >
IGL_INLINE void	triangulate (const Eigen::MatrixBase< DerivedV > &V, const Eigen::MatrixBase< DerivedE > &E, const Eigen::MatrixBase< DerivedH > &H, const std::string flags, Eigen::PlainObjectBase< DerivedV2 > &V2, Eigen::PlainObjectBase< DerivedF2 > &F2)
template<typename DerivedV , typename DerivedE , typename DerivedH , typename DerivedVM , typename DerivedEM , typename DerivedV2 , typename DerivedF2 , typename DerivedVM2 , typename DerivedEM2 >
IGL_INLINE void	triangulate (const Eigen::MatrixBase< DerivedV > &V, const Eigen::MatrixBase< DerivedE > &E, const Eigen::MatrixBase< DerivedH > &H, const Eigen::MatrixBase< DerivedVM > &VM, const Eigen::MatrixBase< DerivedEM > &EM, const std::string flags, Eigen::PlainObjectBase< DerivedV2 > &V2, Eigen::PlainObjectBase< DerivedF2 > &F2, Eigen::PlainObjectBase< DerivedVM2 > &VM2, Eigen::PlainObjectBase< DerivedEM2 > &EM2)

Function Documentation

cdt()

template<typename DerivedV , typename DerivedE , typename DerivedWV , typename DerivedWF , typename DerivedWE , typename DerivedJ >

IGL_INLINE void igl::triangle::cdt	(	const Eigen::MatrixBase< DerivedV > &	V,
		const Eigen::MatrixBase< DerivedE > &	E,
		const std::string &	flags,
		Eigen::PlainObjectBase< DerivedWV > &	WV,
		Eigen::PlainObjectBase< DerivedWF > &	WF,
		Eigen::PlainObjectBase< DerivedWE > &	WE,
		Eigen::PlainObjectBase< DerivedJ > &	J
	)

{
  assert(V.cols() == 2);
  assert(E.cols() == 2);
  typedef typename DerivedV::Scalar Scalar;
  typedef Eigen::Matrix<Scalar,Eigen::Dynamic,2> MatrixX2S;
  //MatrixX2S BV;
  //Eigen::MatrixXi BE;
  //igl::bounding_box(V,BV,BE);
  //WV.resize(V.rows()+BV.rows(),2);
  //WV<<V,BV;
  //WE.resize(E.rows()+BE.rows(),2);
  //WE<<E,(BE.array()+V.rows());
  WV = V;
  WE = E;
  Eigen::VectorXi _;
  igl::remove_duplicate_vertices(DerivedWV(WV),DerivedWE(WE),1e-10,WV,_,J,WE);
  // Remove degenerate edges
  igl::slice_mask(DerivedWE(WE),(WE.array().col(0) != WE.array().col(1)).eval(),1,WE);
  // c flag must be present
  igl::triangle::triangulate(DerivedWV(WV),WE,DerivedWV(),flags,WV,WF);
  Eigen::VectorXi UJ;
  igl::remove_unreferenced(DerivedV(WV),Eigen::MatrixXi(WF),WV,WF,UJ);
  for(int i=0;i<WE.rows();i++) for(int j=0;j<WE.cols();j++) WE(i,j)=UJ(WE(i,j));
  // Remove edges from box
  //WE.conservativeResize(WE.rows()-BE.rows(),2);
  for(int i=0;i<J.size();i++) J(i)=UJ(J(i));
  //J.conservativeResize(J.size()-BV.rows());
}

References _, Eigen::PlainObjectBase< Derived >::cols(), igl::remove_duplicate_vertices(), igl::remove_unreferenced(), Eigen::PlainObjectBase< Derived >::rows(), igl::slice_mask(), and triangulate().

Here is the call graph for this function:

triangulate() [1/2]

template<typename DerivedV , typename DerivedE , typename DerivedH , typename DerivedVM , typename DerivedEM , typename DerivedV2 , typename DerivedF2 , typename DerivedVM2 , typename DerivedEM2 >

IGL_INLINE void igl::triangle::triangulate	(	const Eigen::MatrixBase< DerivedV > &	V,
		const Eigen::MatrixBase< DerivedE > &	E,
		const Eigen::MatrixBase< DerivedH > &	H,
		const Eigen::MatrixBase< DerivedVM > &	VM,
		const Eigen::MatrixBase< DerivedEM > &	EM,
		const std::string	flags,
		Eigen::PlainObjectBase< DerivedV2 > &	V2,
		Eigen::PlainObjectBase< DerivedF2 > &	F2,
		Eigen::PlainObjectBase< DerivedVM2 > &	VM2,
		Eigen::PlainObjectBase< DerivedEM2 > &	EM2
	)

{
  using namespace std;
  using namespace Eigen;
 
  assert( (VM.size() == 0 || V.rows() == VM.size()) && 
    "Vertex markers must be empty or same size as V");
  assert( (EM.size() == 0 || E.rows() == EM.size()) && 
    "Segment markers must be empty or same size as E");
  assert(V.cols() == 2);
  assert(E.size() == 0 || E.cols() == 2);
  assert(H.size() == 0 || H.cols() == 2);
 
  // Prepare the flags
  string full_flags = flags + "pz" + (EM.size() || VM.size() ? "" : "B");
 
  typedef Map< Matrix<double,Dynamic,Dynamic,RowMajor> > MapXdr;
  typedef Map< Matrix<int,Dynamic,Dynamic,RowMajor> > MapXir;
 
  // Prepare the input struct
  triangulateio in;
  in.numberofpoints = V.rows();
  in.pointlist = (double*)calloc(V.size(),sizeof(double));
  {
    MapXdr inpl(in.pointlist,V.rows(),V.cols());
    inpl = V.template cast<double>();
  }
 
  in.numberofpointattributes = 0;
  in.pointmarkerlist = (int*)calloc(V.size(),sizeof(int)) ;
  for(unsigned i=0;i<V.rows();++i) in.pointmarkerlist[i] = VM.size()?VM(i):1;
 
  in.trianglelist = NULL;
  in.numberoftriangles = 0;
  in.numberofcorners = 0;
  in.numberoftriangleattributes = 0;
  in.triangleattributelist = NULL;
 
  in.numberofsegments = E.size()?E.rows():0;
  in.segmentlist = (int*)calloc(E.size(),sizeof(int));
  {
    MapXir insl(in.segmentlist,E.rows(),E.cols());
    insl = E.template cast<int>();
  }
  in.segmentmarkerlist = (int*)calloc(E.rows(),sizeof(int));
  for (unsigned i=0;i<E.rows();++i) in.segmentmarkerlist[i] = EM.size()?EM(i):1;
 
  in.numberofholes = H.size()?H.rows():0;
  in.holelist = (double*)calloc(H.size(),sizeof(double));
  {
    MapXdr inhl(in.holelist,H.rows(),H.cols());
    inhl = H.template cast<double>();
  }
  in.numberofregions = 0;
 
  // Prepare the output struct
  triangulateio out;
  out.pointlist = NULL;
  out.trianglelist = NULL;
  out.segmentlist = NULL;
  out.segmentmarkerlist = NULL;
  out.pointmarkerlist = NULL;
 
  // Call triangle
  ::triangulate(const_cast<char*>(full_flags.c_str()), &in, &out, 0);
 
  // Return the mesh
  V2 = MapXdr(out.pointlist,out.numberofpoints,2).cast<typename DerivedV2::Scalar>();
  F2 = MapXir(out.trianglelist,out.numberoftriangles,3).cast<typename DerivedF2::Scalar>();
  if(VM.size())
  {
    VM2 = MapXir(out.pointmarkerlist,out.numberofpoints,1).cast<typename DerivedVM2::Scalar>();
  }
  if(EM.size())
  {
    EM2 = MapXir(out.segmentmarkerlist,out.numberofsegments,1).cast<typename DerivedEM2::Scalar>();
  }
 
  // Cleanup in
  free(in.pointlist);
  free(in.pointmarkerlist);
  free(in.segmentlist);
  free(in.segmentmarkerlist);
  free(in.holelist);
  // Cleanup out
  free(out.pointlist);
  free(out.trianglelist);
  free(out.segmentlist);
  free(out.segmentmarkerlist);
  free(out.pointmarkerlist);
}

References free().

Here is the call graph for this function:

triangulate() [2/2]

template<typename DerivedV , typename DerivedE , typename DerivedH , typename DerivedV2 , typename DerivedF2 >

IGL_INLINE void igl::triangle::triangulate	(	const Eigen::MatrixBase< DerivedV > &	V,
		const Eigen::MatrixBase< DerivedE > &	E,
		const Eigen::MatrixBase< DerivedH > &	H,
		const std::string	flags,
		Eigen::PlainObjectBase< DerivedV2 > &	V2,
		Eigen::PlainObjectBase< DerivedF2 > &	F2
	)

{
  Eigen::VectorXi VM,EM,VM2,EM2;
  return triangulate(V,E,H,VM,EM,flags,V2,F2,VM2,EM2);
}

References triangulate().

Referenced by cdt(), and triangulate().

Here is the call graph for this function:

Here is the caller graph for this function: