Collaboration diagram for igl::copyleft::comiso::VertexIndexing< DerivedV, DerivedF >:

Classes
struct	VertexInfo

Public Member Functions
IGL_INLINE	VertexIndexing (const Eigen::PlainObjectBase< DerivedV > &_V, const Eigen::PlainObjectBase< DerivedF > &_F, const Eigen::PlainObjectBase< DerivedV > &_Vcut, const Eigen::PlainObjectBase< DerivedF > &_Fcut, const Eigen::PlainObjectBase< DerivedF > &_TT, const Eigen::PlainObjectBase< DerivedF > &_TTi, const Eigen::Matrix< int, Eigen::Dynamic, 3 > &_Handle_MMatch, const Eigen::Matrix< int, Eigen::Dynamic, 1 > &_Handle_Singular, const Eigen::Matrix< int, Eigen::Dynamic, 3 > &_Handle_Seams)

IGL_INLINE void	InitSeamInfo ()

Public Attributes
const Eigen::PlainObjectBase< DerivedV > &	V

const Eigen::PlainObjectBase< DerivedF > &	F

const Eigen::PlainObjectBase< DerivedV > &	Vcut

const Eigen::PlainObjectBase< DerivedF > &	Fcut

const Eigen::PlainObjectBase< DerivedF > &	TT

const Eigen::PlainObjectBase< DerivedF > &	TTi

const Eigen::Matrix< int, Eigen::Dynamic, 3 > &	Handle_MMatch

const Eigen::Matrix< int, Eigen::Dynamic, 1 > &	Handle_Singular

const Eigen::Matrix< int, Eigen::Dynamic, 3 > &	Handle_Seams

MeshSystemInfo	Handle_SystemInfo
	this handle for mesh TODO: move with the other global variables

Private Member Functions
IGL_INLINE void	GetSeamInfo (const int f0, const int f1, const int indexE, int &v0, int &v1, int &v0p, int &v1p, unsigned char &_MMatch)

IGL_INLINE std::vector< std::vector< VertexInfo > >	GetVerticesPerSeam ()

Detailed Description

template<typename DerivedV, typename DerivedF>
class igl::copyleft::comiso::VertexIndexing< DerivedV, DerivedF >

Constructor & Destructor Documentation

◆ VertexIndexing()

template<typename DerivedV , typename DerivedF >

IGL_INLINE igl::copyleft::comiso::VertexIndexing< DerivedV, DerivedF >::VertexIndexing	(	const Eigen::PlainObjectBase< DerivedV > &	_V,
		const Eigen::PlainObjectBase< DerivedF > &	_F,
		const Eigen::PlainObjectBase< DerivedV > &	_Vcut,
		const Eigen::PlainObjectBase< DerivedF > &	_Fcut,
		const Eigen::PlainObjectBase< DerivedF > &	_TT,
		const Eigen::PlainObjectBase< DerivedF > &	_TTi,
		const Eigen::Matrix< int, Eigen::Dynamic, 3 > &	_Handle_MMatch,
		const Eigen::Matrix< int, Eigen::Dynamic, 1 > &	_Handle_Singular,
		const Eigen::Matrix< int, Eigen::Dynamic, 3 > &	_Handle_Seams
	)

                                                                    :
V(_V),
F(_F),
Vcut(_Vcut),
Fcut(_Fcut),
TT(_TT),
TTi(_TTi),
Handle_MMatch(_Handle_MMatch),
Handle_Singular(_Handle_Singular),
Handle_Seams(_Handle_Seams)
{
  #ifdef DEBUG_PRINT
  cerr<<igl::matlab_format(Handle_Seams,"Handle_Seams");
#endif
 
  Handle_SystemInfo.num_vert_variables=Vcut.rows();
  Handle_SystemInfo.num_integer_cuts=0;
}

References igl::copyleft::comiso::VertexIndexing< DerivedV, DerivedF >::Handle_Seams, igl::copyleft::comiso::VertexIndexing< DerivedV, DerivedF >::Handle_SystemInfo, igl::matlab_format(), igl::copyleft::comiso::MeshSystemInfo::num_integer_cuts, igl::copyleft::comiso::MeshSystemInfo::num_vert_variables, Eigen::PlainObjectBase< Derived >::rows(), and igl::copyleft::comiso::VertexIndexing< DerivedV, DerivedF >::Vcut.

Here is the call graph for this function:

Member Function Documentation

◆ GetSeamInfo()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::VertexIndexing< DerivedV, DerivedF >::GetSeamInfo	(	const int	f0,
		const int	f1,
		const int	indexE,
		int &	v0,
		int &	v1,
		int &	v0p,
		int &	v1p,
		unsigned char &	_MMatch
	)

private

{
  int edgef0 = indexE;
  v0 = Fcut(f0,edgef0);
  v1 = Fcut(f0,(edgef0+1)%3);
  assert(TT(f0,edgef0) == f1);
  int edgef1 = TTi(f0,edgef0);
  v1p = Fcut(f1,edgef1);
  v0p = Fcut(f1,(edgef1+1)%3);
 
  _MMatch = Handle_MMatch(f0,edgef0);
  assert(F(f0,edgef0)         == F(f1,((edgef1+1)%3)));
  assert(F(f0,((edgef0+1)%3)) == F(f1,edgef1));
}

◆ GetVerticesPerSeam()

template<typename DerivedV , typename DerivedF >

IGL_INLINE std::vector< std::vector< typename igl::copyleft::comiso::VertexIndexing< DerivedV, DerivedF >::VertexInfo > > igl::copyleft::comiso::VertexIndexing< DerivedV, DerivedF >::GetVerticesPerSeam

private

{
  // Return value
  std::vector<std::vector<VertexInfo> >verticesPerSeam;
 
  // for every vertex, keep track of their adjacent vertices on seams.
  // regular vertices have two neighbors on a seam, start- and endvertices may have any other numbers of neighbors (e.g. 1 or 3)
  std::vector<std::list<VertexInfo> > VVSeam(V.rows());
  Eigen::MatrixXi F_hit = Eigen::MatrixXi::Zero(F.rows(), 3);
  for (unsigned int f=0; f<F.rows();f++)
  {
    int f0 = f;
    for(int k0=0; k0<3; k0++){
      int f1 = TT(f0,k0);
      if(f1 == -1)
        continue;
 
      bool seam = Handle_Seams(f0,k0);
      if (seam && F_hit(f0,k0) == 0)
      {
        int v0 = F(f0, k0);
        int v1 = F(f0, (k0+1)%3);
        int k1 = TTi(f0,k0);
        VVSeam[v0].push_back(VertexInfo(v1, f0, k0, f1, k1));
        VVSeam[v1].push_back(VertexInfo(v0, f0, k0, f1, k1));
        F_hit(f0, k0) = 1;
        F_hit(f1, k1) = 1;
      }
    }
  }
 
  // Find start vertices, i.e. vertices that start or end a seam branch
  std::vector<int> startVertexIndices;
  std::vector<bool> isStartVertex(V.rows());
  for (unsigned int i=0;i<V.rows();i++)
  {
    isStartVertex[i] = false;
    // vertices with two neighbors are regular vertices, unless the vertex is a singularity, in which case it qualifies as a start vertex
    if (VVSeam[i].size() > 0 && VVSeam[i].size() != 2 || Handle_Singular(i) == true)
    {
      startVertexIndices.push_back(i);
      isStartVertex[i] = true;
    }
  }
 
  // For each startVertex, walk along its seam
  for (unsigned int i=0;i<startVertexIndices.size();i++)
  {
    auto startVertexNeighbors = &VVSeam[startVertexIndices[i]];
    const int neighborSize = startVertexNeighbors->size();
 
    // explore every seam to which this vertex is a start vertex
    // note: a vertex can never be a start vertex and a regular vertex simultaneously
    for (unsigned int j=0;j<neighborSize;j++)
    {
      std::vector<VertexInfo> thisSeam; // temporary container
 
      // Create vertexInfo struct for start vertex
      auto startVertex = VertexInfo(startVertexIndices[i], -1, -1, -1, -1);// -1 values are arbitrary (will never be used)
      auto currentVertex = startVertex;
      // Add start vertex to the seam
      thisSeam.push_back(currentVertex);
 
      // advance on the seam
      auto currentVertexNeighbors = startVertexNeighbors;
      auto nextVertex = currentVertexNeighbors->front();
      currentVertexNeighbors->pop_front();
 
      auto prevVertex = startVertex; // bogus initialization to get the type
      while (true)
      {
        // move to the next vertex
        prevVertex = currentVertex;
        currentVertex = nextVertex;
        currentVertexNeighbors = &VVSeam[nextVertex.v];
 
        // add current vertex to this seam
        thisSeam.push_back(currentVertex);
 
        // remove the previous vertex
        auto it = std::find(currentVertexNeighbors->begin(), currentVertexNeighbors->end(), prevVertex);
        assert(it != currentVertexNeighbors->end());
        currentVertexNeighbors->erase(it);
 
        if (currentVertexNeighbors->size() == 1 && !isStartVertex[currentVertex.v])
        {
          nextVertex = currentVertexNeighbors->front();
          currentVertexNeighbors->pop_front();
        }
        else
          break;
      }
      verticesPerSeam.push_back(thisSeam);
    }
  }
 
  return verticesPerSeam;
}

◆ InitSeamInfo()

template<typename DerivedV , typename DerivedF >

IGL_INLINE void igl::copyleft::comiso::VertexIndexing< DerivedV, DerivedF >::InitSeamInfo

{
  auto verticesPerSeam = GetVerticesPerSeam();
  Handle_SystemInfo.EdgeSeamInfo.clear();
  int integerVar = 0;
  // Loop over each seam
  for(auto seam : verticesPerSeam){
    //choose initial side of the seam such that the start vertex corresponds to Fcut(f, k) and the end vertex corresponds to Fcut(f, (k+1)%3) and not vice versa.
    int priorVertexIdx;
    if(seam.size() > 2){
      auto v1 = seam[1];
      auto v2 = seam[2];
      if(Fcut(v1.f0, (v1.k0+1) % 3) == Fcut(v2.f0, v2.k0) || Fcut(v1.f0, (v1.k0+1) % 3) == Fcut(v2.f1, v2.k1)){
        priorVertexIdx = Fcut(v1.f0, v1.k0);
      }
      else{
        priorVertexIdx = Fcut(v1.f1, v1.k1);
        assert(Fcut(v1.f1, (v1.k1+1) % 3) == Fcut(v2.f0, v2.k0) || Fcut(v1.f1, (v1.k1+1) % 3) == Fcut(v2.f1, v2.k1));
      }
    }
    else{
      auto v1 = seam[1];
      priorVertexIdx = Fcut(v1.f0, v1.k0);
    }
 
    // Loop over each vertex of the seam
    for(auto it=seam.begin()+1; it != seam.end(); ++it){
      auto vertex = *it;
      // choose the correct side of the seam
      int f,k,ff,kk;
      if(priorVertexIdx == Fcut(vertex.f0, vertex.k0)){
        f = vertex.f0; ff = vertex.f1;
        k = vertex.k0; kk = vertex.k1;
      }
      else{
        f = vertex.f1; ff = vertex.f0;
        k = vertex.k1; kk = vertex.k0;
        assert(priorVertexIdx == Fcut(vertex.f1, vertex.k1));
      }
 
      int vtx0,vtx0p,vtx1,vtx1p;
      unsigned char MM;
      GetSeamInfo(f,ff,k,vtx0,vtx1,vtx0p,vtx1p,MM);
      Handle_SystemInfo.EdgeSeamInfo.push_back(SeamInfo(vtx0,vtx0p,MM,integerVar));
      if(it == seam.end() -1){
        Handle_SystemInfo.EdgeSeamInfo.push_back(SeamInfo(vtx1,vtx1p,MM,integerVar));
      }
      priorVertexIdx = vtx1;
    }
    // use the same integer for each seam
    integerVar++;
  }
  Handle_SystemInfo.num_integer_cuts = integerVar;
 
#ifndef NDEBUG
  int totalNVerticesOnSeams = 0;
  for(auto seam : verticesPerSeam){
    totalNVerticesOnSeams += seam.size();
  }
  assert(Handle_SystemInfo.EdgeSeamInfo.size() == totalNVerticesOnSeams);
#endif
}