igl::copyleft::cork Namespace Reference

Functions
template<typename DerivedV , typename DerivedF >
IGL_INLINE void	from_cork_mesh (const CorkTriMesh &mesh, Eigen::PlainObjectBase< DerivedV > &V, Eigen::PlainObjectBase< DerivedF > &F)
template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedVC , typename DerivedFC >
IGL_INLINE void	mesh_boolean (const Eigen::PlainObjectBase< DerivedVA > &VA, const Eigen::PlainObjectBase< DerivedFA > &FA, const Eigen::PlainObjectBase< DerivedVB > &VB, const Eigen::PlainObjectBase< DerivedFB > &FB, const MeshBooleanType &type, Eigen::PlainObjectBase< DerivedVC > &VC, Eigen::PlainObjectBase< DerivedFC > &FC)
template<typename DerivedV , typename DerivedF >
IGL_INLINE void	to_cork_mesh (const Eigen::PlainObjectBase< DerivedV > &V, const Eigen::PlainObjectBase< DerivedF > &F, CorkTriMesh &mesh)

Function Documentation

from_cork_mesh()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::cork::from_cork_mesh	(	const CorkTriMesh &	mesh,
		Eigen::PlainObjectBase< DerivedV > &	V,
		Eigen::PlainObjectBase< DerivedF > &	F
	)

{
  using namespace std;
  F.resize(mesh.n_triangles,3);
  V.resize(mesh.n_vertices,3);
  for(size_t v = 0;v<mesh.n_vertices;v++)
  {
    for(size_t c = 0;c<3;c++)
    {
      V(v,c) = mesh.vertices[v*3+c];
    }
  }
  for(size_t f = 0;f<mesh.n_triangles;f++)
  {
    for(size_t c = 0;c<3;c++)
    {
      F(f,c) = mesh.triangles[f*3+c];
    }
  }
}

References Eigen::PlainObjectBase< Derived >::resize().

Referenced by mesh_boolean().

Here is the call graph for this function:

Here is the caller graph for this function:

mesh_boolean()

template<typename DerivedVA , typename DerivedFA , typename DerivedVB , typename DerivedFB , typename DerivedVC , typename DerivedFC >

IGL_INLINE void igl::copyleft::cork::mesh_boolean	(	const Eigen::PlainObjectBase< DerivedVA > &	VA,
		const Eigen::PlainObjectBase< DerivedFA > &	FA,
		const Eigen::PlainObjectBase< DerivedVB > &	VB,
		const Eigen::PlainObjectBase< DerivedFB > &	FB,
		const MeshBooleanType &	type,
		Eigen::PlainObjectBase< DerivedVC > &	VC,
		Eigen::PlainObjectBase< DerivedFC > &	FC
	)

{
  CorkTriMesh A,B,C;
  // pointer to output so it's easy to redirect on degenerate cases
  CorkTriMesh *ret = &C;
  to_cork_mesh(VA,FA,A);
  to_cork_mesh(VB,FB,B);
  switch(type)
  {
    case MESH_BOOLEAN_TYPE_UNION:
      if(A.n_triangles == 0)
      {
        ret = &B;
      }else if(B.n_triangles == 0)
      {
        ret = &A;
      }else
      {
        computeUnion(A,B,ret);
      }
      break;
    case MESH_BOOLEAN_TYPE_INTERSECT:
      if(A.n_triangles == 0 || B.n_triangles == 0)
      {
        ret->n_triangles = 0;
        ret->n_vertices = 0;
      }else
      {
        computeIntersection(A,B,ret);
      }
      break;
    case MESH_BOOLEAN_TYPE_MINUS:
      if(A.n_triangles == 0)
      {
        ret->n_triangles = 0;
        ret->n_vertices = 0;
      }else if(B.n_triangles == 0)
      {
        ret = &A;
      }else
      {
        computeDifference(A,B,ret);
      }
      break;
    case MESH_BOOLEAN_TYPE_XOR:
      if(A.n_triangles == 0)
      {
        ret = &B;
      }else if(B.n_triangles == 0)
      {
        ret = &A;
      }else
      {
        computeSymmetricDifference(A,B,&C);
      }
      break;
    case MESH_BOOLEAN_TYPE_RESOLVE:
      resolveIntersections(A,B,&C);
      break;
    default:
      assert(false && "Unknown type");
      return;
  }
  from_cork_mesh(*ret,VC,FC);
  freeCorkTriMesh(&A);
  freeCorkTriMesh(&B);
  freeCorkTriMesh(&C);
}

References from_cork_mesh(), igl::MESH_BOOLEAN_TYPE_INTERSECT, igl::MESH_BOOLEAN_TYPE_MINUS, igl::MESH_BOOLEAN_TYPE_RESOLVE, igl::MESH_BOOLEAN_TYPE_UNION, igl::MESH_BOOLEAN_TYPE_XOR, and to_cork_mesh().

Here is the call graph for this function:

to_cork_mesh()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::cork::to_cork_mesh	(	const Eigen::PlainObjectBase< DerivedV > &	V,
		const Eigen::PlainObjectBase< DerivedF > &	F,
		CorkTriMesh &	mesh
	)

{
  using namespace std;
  assert((F.cols() == 0 || F.cols() == 3) && "Facets should be triangles.");
  assert((V.cols() == 0 || V.cols() == 3) && "Vertices should be in 3D.");
  mesh.n_triangles = F.rows();
  mesh.n_vertices = V.rows();
  mesh.vertices = new float[mesh.n_vertices*3];
  mesh.triangles = new uint[mesh.n_triangles*3];
  for(size_t v = 0;v<mesh.n_vertices;v++)
  {
    for(size_t c = 0;c<3;c++)
    {
      mesh.vertices[v*3+c] = V(v,c);
    }
  }
  for(size_t f = 0;f<mesh.n_triangles;f++)
  {
    for(size_t c = 0;c<3;c++)
    {
      mesh.triangles[f*3+c] = F(f,c);
    }
  }
}

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

Referenced by mesh_boolean().

Here is the call graph for this function:

Here is the caller graph for this function: