libigl_Martin/include/igl/find_cross_field_singularities.cpp

#include "find_cross_field_singularities.h"
#include "cross_field_missmatch.h"

#include <vector>
#include "is_border_vertex.h"
#include "vf.h"
#include "is_border_vertex.h"
#include "cross_field_missmatch.h"


template <typename DerivedV, typename DerivedF, typename DerivedM, typename DerivedO>
IGL_INLINE void igl::find_cross_field_singularities(const Eigen::PlainObjectBase<DerivedV> &V,
                                                    const Eigen::PlainObjectBase<DerivedF> &F,
                                                    const Eigen::PlainObjectBase<DerivedM> &Handle_MMatch,
                                                    Eigen::PlainObjectBase<DerivedO> &isSingularity,
                                                    Eigen::PlainObjectBase<DerivedO> &singularityIndex)
{
  std::vector<bool> V_border = igl::is_border_vertex(V,F);
  
  std::vector<std::vector<int> > VF;
  std::vector<std::vector<int> > VFi;
  igl::vf(V,F,VF,VFi);
  

  isSingularity.setZero(V.rows(),1);
  singularityIndex.setZero(V.rows(),1);
  for (unsigned int vid=0;vid<V.rows();vid++)
  {
    ///check that is on border..
    if (V_border[vid])
      return;
    
    int missmatch=0;
    for (unsigned int i=0;i<VF[vid].size();i++)
    {
      // look for the vertex
      int j=-1;
      for (unsigned z=0; z<3; ++z)
        if (F(VF[vid][i],z) == vid)
          j=z;
      assert(j!=-1);
      
      missmatch+=Handle_MMatch(VF[vid][i],j);
    }
    missmatch=missmatch%4;
    
    isSingularity(vid)=(missmatch!=0);
    singularityIndex(vid)=missmatch;
  }
  

}

template <typename DerivedV, typename DerivedF, typename DerivedO>
IGL_INLINE void igl::find_cross_field_singularities(const Eigen::PlainObjectBase<DerivedV> &V,
                                                    const Eigen::PlainObjectBase<DerivedF> &F,
                                                    const Eigen::PlainObjectBase<DerivedV> &PD1,
                                                    const Eigen::PlainObjectBase<DerivedV> &PD2,
                                                    Eigen::PlainObjectBase<DerivedO> &isSingularity,
                                                    Eigen::PlainObjectBase<DerivedO> &singularityIndex)
{

  Eigen::Matrix<typename DerivedV::Scalar, Eigen::Dynamic, 3> Handle_MMatch;
  igl::cross_field_missmatch<DerivedV, DerivedF, DerivedO>(V, F, PD1, PD2, Handle_MMatch);
  igl::find_cross_field_singularities(V, F, Handle_MMatch, isSingularity, singularityIndex);
}