Collaboration diagram for igl::MissMatchCalculatorLine< DerivedV, DerivedF, DerivedO >:

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

void	calculateMissmatchLine (Eigen::PlainObjectBase< DerivedO > &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	MissMatchByLine (const int f0, const int f1)

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 DerivedO>
class igl::MissMatchCalculatorLine< DerivedV, DerivedF, DerivedO >

Constructor & Destructor Documentation

◆ MissMatchCalculatorLine()

template<typename DerivedV , typename DerivedF , typename DerivedO >

igl::MissMatchCalculatorLine< DerivedV, DerivedF, DerivedO >::MissMatchCalculatorLine	(	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

◆ calculateMissmatchLine()

template<typename DerivedV , typename DerivedF , typename DerivedO >

void igl::MissMatchCalculatorLine< DerivedV, DerivedF, DerivedO >::calculateMissmatchLine ( Eigen::PlainObjectBase< DerivedO > & Handle_MMatch )

inline

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

References igl::MissMatchCalculatorLine< DerivedV, DerivedF, DerivedO >::F, igl::MissMatchCalculatorLine< DerivedV, DerivedF, DerivedO >::MissMatchByLine(), Eigen::PlainObjectBase< Derived >::rows(), Eigen::PlainObjectBase< Derived >::setConstant(), and igl::MissMatchCalculatorLine< DerivedV, DerivedF, DerivedO >::TT.

Referenced by igl::line_field_missmatch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MissMatchByLine()

template<typename DerivedV , typename DerivedF , typename DerivedO >

int igl::MissMatchCalculatorLine< DerivedV, DerivedF, DerivedO >::MissMatchByLine	(	const int	f0,
		const int	f1
	)

inlineprivate

    {
        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)));
 
        double step=igl::PI;
        int i=(int)std::floor((angle_diff/step)+0.5);
        assert((i>=-2)&&(i<=2));
        int k=0;
        if (i>=0)
            k=i%2;
        else
            k=(2+i)%2;
 
        assert((k==0)||(k==1));
        return (k*2);
    }