igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC > Class Template Reference

Collaboration diagram for igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >:

Public Member Functions
IGL_INLINE	MeshCutterMini (const Eigen::PlainObjectBase< DerivedV > &_V, const Eigen::PlainObjectBase< DerivedF > &_F, const Eigen::PlainObjectBase< DerivedTT > &_TT, const Eigen::PlainObjectBase< DerivedTT > &_TTi, const std::vector< std::vector< VFType > > &_VF, const std::vector< std::vector< VFType > > &_VFi, const std::vector< bool > &_V_border, const Eigen::PlainObjectBase< DerivedC > &_Handle_Seams)
IGL_INLINE void	InitMappingSeam ()
	vertex to variable mapping initialize the mapping for a given sampled mesh

Public Attributes
const Eigen::PlainObjectBase< DerivedV > &	V
const Eigen::PlainObjectBase< DerivedF > &	F
const Eigen::PlainObjectBase< DerivedTT > &	TT
const Eigen::PlainObjectBase< DerivedTT > &	TTi
const std::vector< std::vector< VFType > > &	VF
const std::vector< std::vector< VFType > > &	VFi
const std::vector< bool > &	V_border
const Eigen::PlainObjectBase< DerivedC > &	Handle_Seams
int	num_scalar_variables
DerivedF	HandleS_Index
std::vector< std::vector< int > >	HandleV_Integer

Private Member Functions
IGL_INLINE void	FirstPos (const int v, int &f, int &edge)
IGL_INLINE int	AddNewIndex (const int v0)
IGL_INLINE bool	IsSeam (const int f0, const int f1)
IGL_INLINE void	FindInitialPos (const int vert, int &edge, int &face)
	find initial position of the pos to
IGL_INLINE void	MapIndexes (const int vert, const int edge_init, const int f_init)
	initialize the mapping given an initial pos whih must be initialized with FindInitialPos
IGL_INLINE void	InitMappingSeam (const int vert)
	initialize the mapping for a given vertex

Detailed Description

template<typename DerivedV, typename DerivedF, typename VFType, typename DerivedTT, typename DerivedC>
class igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >

Constructor & Destructor Documentation

MeshCutterMini()

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

IGL_INLINE igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::MeshCutterMini	(	const Eigen::PlainObjectBase< DerivedV > &	_V,
		const Eigen::PlainObjectBase< DerivedF > &	_F,
		const Eigen::PlainObjectBase< DerivedTT > &	_TT,
		const Eigen::PlainObjectBase< DerivedTT > &	_TTi,
		const std::vector< std::vector< VFType > > &	_VF,
		const std::vector< std::vector< VFType > > &	_VFi,
		const std::vector< bool > &	_V_border,
		const Eigen::PlainObjectBase< DerivedC > &	_Handle_Seams
	)

                                                      :
  V(_V),
  F(_F),
  TT(_TT),
  TTi(_TTi),
  VF(_VF),
  VFi(_VFi),
  V_border(_V_border),
  Handle_Seams(_Handle_Seams)
{
  num_scalar_variables=0;
  HandleS_Index.setConstant(F.rows(),3,-1);
  HandleV_Integer.resize(V.rows());
}

References igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::F, igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::HandleS_Index, igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::HandleV_Integer, igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::num_scalar_variables, Eigen::PlainObjectBase< Derived >::rows(), and igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::V.

Here is the call graph for this function:

Member Function Documentation

AddNewIndex()

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

IGL_INLINE int igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::AddNewIndex ( const int  v0 )

private

{
  num_scalar_variables++;
  HandleV_Integer[v0].push_back(num_scalar_variables);
  return num_scalar_variables;
}

FindInitialPos()

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

IGL_INLINE void igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::FindInitialPos ( const int  vert, int &  edge, int &  face  )

private

find initial position of the pos to

test if I've just crossed a border

or if I've just crossed a seam if I'm on a border I MUST start from the one next t othe border

{
  int f_init;
  int edge_init;
  FirstPos(vert,f_init,edge_init); // todo manually the function
  igl::HalfEdgeIterator<DerivedF,DerivedTT,DerivedTT> VFI(F,TT,TTi,f_init,edge_init);
 
  bool vertexB = V_border[vert];
  bool possible_split=false;
  bool complete_turn=false;
  do
  {
    int curr_f = VFI.Fi();
    int curr_edge=VFI.Ei();
    VFI.NextFE();
    int next_f=VFI.Fi();
    bool on_border=(TT(curr_f,curr_edge)==-1);
    //bool mismatch=false;
    bool seam=false;
 
    if (!vertexB)
      //seam=curr_f->IsSeam(next_f);
      seam=IsSeam(curr_f,next_f);
    //    if (vertexB)
    //      assert(!Handle_Singular(vert));
    //    ;
    //assert(!vert->IsSingular());
    possible_split=((on_border)||(seam));
    complete_turn = next_f == f_init;
  } while ((!possible_split)&&(!complete_turn));
  face=VFI.Fi();
  edge=VFI.Ei();
}

References igl::HalfEdgeIterator< DerivedF, DerivedFF, DerivedFFi >::Ei(), igl::HalfEdgeIterator< DerivedF, DerivedFF, DerivedFFi >::Fi(), and igl::HalfEdgeIterator< DerivedF, DerivedFF, DerivedFFi >::NextFE().

Here is the call graph for this function:

FirstPos()

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

IGL_INLINE void igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::FirstPos ( const int  v, int &  f, int &  edge  )

private

{
  f    = VF[v][0];  // f=v->cVFp();
  edge = VFi[v][0]; // edge=v->cVFi();
}

InitMappingSeam() [1/2]

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

IGL_INLINE void igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::InitMappingSeam

vertex to variable mapping initialize the mapping for a given sampled mesh

{
  num_scalar_variables=-1;
  for (unsigned int i=0;i<V.rows();i++)
    InitMappingSeam(i);
 
  for (unsigned int j=0;j<V.rows();j++)
    assert(HandleV_Integer[j].size()>0);
}

Referenced by igl::cut_mesh().

Here is the caller graph for this function:

InitMappingSeam() [2/2]

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

IGL_INLINE void igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::InitMappingSeam ( const int  vert )

private

initialize the mapping for a given vertex

first rotate until find the first pos after a mismatch or a border or return to the first position...

{
  int f_init = VF[vert][0];
  int indexE = VFi[vert][0];
 
  igl::HalfEdgeIterator<DerivedF,DerivedTT,DerivedTT> VFI(F,TT,TTi,f_init,indexE);
 
  int edge_init;
  int face_init;
  FindInitialPos(vert,edge_init,face_init);
  MapIndexes(vert,edge_init,face_init);
}

IsSeam()

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

IGL_INLINE bool igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::IsSeam ( const int  f0, const int  f1  )

private

border

{
  for (int i=0;i<3;i++)
  {
    int f_clos = TT(f0,i);
 
    if (f_clos == -1)
      continue; 
 
    if (f_clos == f1)
      return(Handle_Seams(f0,i));
  }
  assert(0);
  return false;
}

MapIndexes()

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

IGL_INLINE void igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::MapIndexes ( const int  vert, const int  edge_init, const int  f_init  )

private

initialize the mapping given an initial pos whih must be initialized with FindInitialPos

check that is not on border.. in such case maybe it's non manyfold insert an initial index

and initialize the jumping pos

assing the current index

test if I've finiseh with the face exploration

or if I've just crossed a mismatch

then add a new index

{
  int curr_index=AddNewIndex(vert);
  igl::HalfEdgeIterator<DerivedF,DerivedTT,DerivedTT> VFI(F,TT,TTi,f_init,edge_init);
  bool complete_turn=false;
  do
  {
    int curr_f = VFI.Fi();
    int curr_edge = VFI.Ei();
    HandleS_Index(curr_f,curr_edge) = curr_index;
    VFI.NextFE();
    int next_f = VFI.Fi();
    complete_turn = (next_f==f_init);
    if (!complete_turn)
    {
      bool seam=false;
      //seam=curr_f->IsSeam(next_f);
      seam=IsSeam(curr_f,next_f);
      if (seam)
      {
        curr_index=AddNewIndex(vert);
      }
    }
  } while (!complete_turn);
}

References igl::HalfEdgeIterator< DerivedF, DerivedFF, DerivedFFi >::Ei(), igl::HalfEdgeIterator< DerivedF, DerivedFF, DerivedFFi >::Fi(), and igl::HalfEdgeIterator< DerivedF, DerivedFF, DerivedFFi >::NextFE().

Here is the call graph for this function:

Member Data Documentation

F

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

const Eigen::PlainObjectBase<DerivedF>& igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::F

Referenced by igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::MeshCutterMini().

Handle_Seams

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

const Eigen::PlainObjectBase<DerivedC>& igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::Handle_Seams

HandleS_Index

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

DerivedF igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::HandleS_Index

Referenced by igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::MeshCutterMini(), and igl::cut_mesh().

HandleV_Integer

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

std::vector<std::vector<int> > igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::HandleV_Integer

Referenced by igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::MeshCutterMini(), and igl::cut_mesh().

num_scalar_variables

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

int igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::num_scalar_variables

Referenced by igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::MeshCutterMini().

TT

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

const Eigen::PlainObjectBase<DerivedTT>& igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::TT

TTi

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

const Eigen::PlainObjectBase<DerivedTT>& igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::TTi

V

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

const Eigen::PlainObjectBase<DerivedV>& igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::V

Referenced by igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::MeshCutterMini().

V_border

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

const std::vector<bool>& igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::V_border

VF

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

const std::vector<std::vector<VFType> >& igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::VF

VFi

template<typename DerivedV , typename DerivedF , typename VFType , typename DerivedTT , typename DerivedC >

const std::vector<std::vector<VFType> >& igl::MeshCutterMini< DerivedV, DerivedF, VFType, DerivedTT, DerivedC >::VFi

---

The documentation for this class was generated from the following file:

• src/libigl/igl/cut_mesh.cpp