Collaboration diagram for igl::MissMatchCalculator< DerivedV, DerivedF, DerivedM >:

Public Member Functions
	MissMatchCalculator (const Eigen::PlainObjectBase< DerivedV > &_V, const Eigen::PlainObjectBase< DerivedF > &_F, const Eigen::PlainObjectBase< DerivedV > &_PD1, const Eigen::PlainObjectBase< DerivedV > &_PD2)

void	calculateMissmatch (Eigen::PlainObjectBase< DerivedM > &Handle_MMatch)

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

const Eigen::PlainObjectBase< DerivedF > &	F

const Eigen::PlainObjectBase< DerivedV > &	PD1

const Eigen::PlainObjectBase< DerivedV > &	PD2

DerivedV	N

Private Member Functions
int	MissMatchByCross (const int f0, const int f1)
	compute the mismatch between 2 faces

Private Attributes
std::vector< bool >	V_border

std::vector< std::vector< int > >	VF

std::vector< std::vector< int > >	VFi

DerivedF	TT

DerivedF	TTi

Detailed Description

template<typename DerivedV, typename DerivedF, typename DerivedM>
class igl::MissMatchCalculator< DerivedV, DerivedF, DerivedM >

Constructor & Destructor Documentation

◆ MissMatchCalculator()

template<typename DerivedV , typename DerivedF , typename DerivedM >

igl::MissMatchCalculator< DerivedV, DerivedF, DerivedM >::MissMatchCalculator	(	const Eigen::PlainObjectBase< DerivedV > &	_V,
		const Eigen::PlainObjectBase< DerivedF > &	_F,
		const Eigen::PlainObjectBase< DerivedV > &	_PD1,
		const Eigen::PlainObjectBase< DerivedV > &	_PD2
	)

inline

                       :
  V(_V),
  F(_F),
  PD1(_PD1),
  PD2(_PD2)
  {
    igl::per_face_normals(V,F,N);
    V_border = igl::is_border_vertex(V,F);
    igl::vertex_triangle_adjacency(V,F,VF,VFi);
    igl::triangle_triangle_adjacency(F,TT,TTi);
  }

Here is the call graph for this function:

Member Function Documentation

◆ calculateMissmatch()

template<typename DerivedV , typename DerivedF , typename DerivedM >

void igl::MissMatchCalculator< DerivedV, DerivedF, DerivedM >::calculateMissmatch ( Eigen::PlainObjectBase< DerivedM > & Handle_MMatch )

inline

  {
    Handle_MMatch.setConstant(F.rows(),3,-1);
    for (size_t i=0;i<F.rows();i++)
    {
      for (int j=0;j<3;j++)
      {
        if (((int)i)==TT(i,j) || TT(i,j) == -1)
          Handle_MMatch(i,j)=0;
        else
          Handle_MMatch(i,j) = MissMatchByCross(i,TT(i,j));
      }
    }
  }

References igl::MissMatchCalculator< DerivedV, DerivedF, DerivedM >::F, igl::MissMatchCalculator< DerivedV, DerivedF, DerivedM >::MissMatchByCross(), Eigen::PlainObjectBase< Derived >::rows(), Eigen::PlainObjectBase< Derived >::setConstant(), and igl::MissMatchCalculator< DerivedV, DerivedF, DerivedM >::TT.

Referenced by igl::cross_field_missmatch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MissMatchByCross()

template<typename DerivedV , typename DerivedF , typename DerivedM >

int igl::MissMatchCalculator< DerivedV, DerivedF, DerivedM >::MissMatchByCross	(	const int	f0,
		const int	f1
	)

inlineprivate

compute the mismatch between 2 faces

    {
      Eigen::Matrix<typename DerivedV::Scalar, 3, 1> dir0 = PD1.row(f0);
      Eigen::Matrix<typename DerivedV::Scalar, 3, 1> dir1 = PD1.row(f1);
      Eigen::Matrix<typename DerivedV::Scalar, 3, 1> n0 = N.row(f0);
      Eigen::Matrix<typename DerivedV::Scalar, 3, 1> n1 = N.row(f1);
 
      Eigen::Matrix<typename DerivedV::Scalar, 3, 1> dir1Rot = igl::rotation_matrix_from_directions(n1,n0)*dir1;
      dir1Rot.normalize();
 
      // TODO: this should be equivalent to the other code below, to check!
      // Compute the angle between the two vectors
      //    double a0 = atan2(dir0.dot(B2.row(f0)),dir0.dot(B1.row(f0)));
      //    double a1 = atan2(dir1Rot.dot(B2.row(f0)),dir1Rot.dot(B1.row(f0)));
      //
      //    double angle_diff = a1-a0;   //VectToAngle(f0,dir1Rot);
 
      double angle_diff = atan2(dir1Rot.dot(PD2.row(f0)),dir1Rot.dot(PD1.row(f0)));
 
      //    std::cerr << "Dani: " << dir0(0) << " " << dir0(1) << " " << dir0(2) << " " << dir1Rot(0) << " " << dir1Rot(1) << " " << dir1Rot(2) << " " << angle_diff << std::endl;
 
      double step=igl::PI/2.0;
      int i=(int)std::floor((angle_diff/step)+0.5);
      int k=0;
      if (i>=0)
        k=i%4;
      else
        k=(-(3*i))%4;
      return k;
    }