Collaboration diagram for igl::Comb< DerivedV, DerivedF >:

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

void	comb (Eigen::PlainObjectBase< DerivedV > &PD1out, Eigen::PlainObjectBase< DerivedV > &PD2out)

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

const Eigen::PlainObjectBase< DerivedF > &	F

const Eigen::PlainObjectBase< DerivedV > &	PD1

const Eigen::PlainObjectBase< DerivedV > &	PD2

DerivedV	N

Static Private Member Functions
static double	Sign (double a)

static Eigen::Matrix< typename DerivedV::Scalar, 3, 1 >	K_PI_new (const Eigen::Matrix< typename DerivedV::Scalar, 3, 1 > &a, const Eigen::Matrix< typename DerivedV::Scalar, 3, 1 > &b, const Eigen::Matrix< typename DerivedV::Scalar, 3, 1 > &n)
	a and b should be in the same plane orthogonal to N

Private Attributes
DerivedF	TT

DerivedF	TTi

Detailed Description

template<typename DerivedV, typename DerivedF>
class igl::Comb< DerivedV, DerivedF >

Constructor & Destructor Documentation

◆ Comb()

template<typename DerivedV , typename DerivedF >

igl::Comb< DerivedV, DerivedF >::Comb	(	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);
      igl::triangle_triangle_adjacency(F,TT,TTi);
    }

References igl::Comb< DerivedV, DerivedF >::F, igl::Comb< DerivedV, DerivedF >::N, igl::per_face_normals(), igl::triangle_triangle_adjacency(), igl::Comb< DerivedV, DerivedF >::TT, igl::Comb< DerivedV, DerivedF >::TTi, and igl::Comb< DerivedV, DerivedF >::V.

Here is the call graph for this function:

Member Function Documentation

◆ comb()

template<typename DerivedV , typename DerivedF >

void igl::Comb< DerivedV, DerivedF >::comb	(	Eigen::PlainObjectBase< DerivedV > &	PD1out,
		Eigen::PlainObjectBase< DerivedV > &	PD2out
	)

inline

    {
//      PD1out = PD1;
//      PD2out = PD2;
      PD1out.setZero(F.rows(),3);PD1out<<PD1;
      PD2out.setZero(F.rows(),3);PD2out<<PD2;
 
      Eigen::VectorXi mark = Eigen::VectorXi::Constant(F.rows(),false);
 
      std::deque<int> d;
 
      d.push_back(0);
      mark(0) = true;
 
      while (!d.empty())
      {
        int f0 = d.at(0);
        d.pop_front();
        for (int k=0; k<3; k++)
        {
          int f1 = TT(f0,k);
          if (f1==-1) continue;
          if (mark(f1)) continue;
 
          Eigen::Matrix<typename DerivedV::Scalar, 3, 1> dir0    = PD1out.row(f0);
          Eigen::Matrix<typename DerivedV::Scalar, 3, 1> dir1    = PD1out.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> dir0Rot = igl::rotation_matrix_from_directions(n0, n1)*dir0;
          dir0Rot.normalize();
          Eigen::Matrix<typename DerivedV::Scalar, 3, 1> targD   = K_PI_new(dir1,dir0Rot,n1);
 
          PD1out.row(f1)  = targD;
          PD2out.row(f1)  = n1.cross(targD).normalized();
 
          mark(f1) = true;
          d.push_back(f1);
 
        }
      }
 
      // everything should be marked
      for (int i=0; i<F.rows(); i++)
      {
        assert(mark(i));
      }
    }

References igl::Comb< DerivedV, DerivedF >::F, igl::Comb< DerivedV, DerivedF >::K_PI_new(), igl::Comb< DerivedV, DerivedF >::N, igl::Comb< DerivedV, DerivedF >::PD1, igl::Comb< DerivedV, DerivedF >::PD2, igl::rotation_matrix_from_directions(), Eigen::PlainObjectBase< Derived >::rows(), Eigen::PlainObjectBase< Derived >::setZero(), and igl::Comb< DerivedV, DerivedF >::TT.

Referenced by igl::comb_cross_field().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ K_PI_new()

template<typename DerivedV , typename DerivedF >

static Eigen::Matrix< typename DerivedV::Scalar, 3, 1 > igl::Comb< DerivedV, DerivedF >::K_PI_new	(	const Eigen::Matrix< typename DerivedV::Scalar, 3, 1 > &	a,
		const Eigen::Matrix< typename DerivedV::Scalar, 3, 1 > &	b,
		const Eigen::Matrix< typename DerivedV::Scalar, 3, 1 > &	n
	)

inlinestaticprivate

a and b should be in the same plane orthogonal to N

    {
      Eigen::Matrix<typename DerivedV::Scalar, 3, 1> c = (a.cross(n)).normalized();
      typename DerivedV::Scalar scorea = a.dot(b);
      typename DerivedV::Scalar scorec = c.dot(b);
      if (fabs(scorea)>=fabs(scorec))
        return a*Sign(scorea);
      else
        return c*Sign(scorec);
    }