CurvatureCalculator Class Reference

Collaboration diagram for CurvatureCalculator:

Classes
class	Quadric

Public Member Functions
IGL_INLINE	CurvatureCalculator ()
IGL_INLINE void	init (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F)
IGL_INLINE void	finalEigenStuff (int, const std::vector< Eigen::Vector3d > &, Quadric &)
IGL_INLINE void	fitQuadric (const Eigen::Vector3d &, const std::vector< Eigen::Vector3d > &ref, const std::vector< int > &, Quadric *)
IGL_INLINE void	applyProjOnPlane (const Eigen::Vector3d &, const std::vector< int > &, std::vector< int > &)
IGL_INLINE void	getSphere (const int, const double, std::vector< int > &, int min)
IGL_INLINE void	getKRing (const int, const double, std::vector< int > &)
IGL_INLINE Eigen::Vector3d	project (const Eigen::Vector3d &, const Eigen::Vector3d &, const Eigen::Vector3d &)
IGL_INLINE void	computeReferenceFrame (int, const Eigen::Vector3d &, std::vector< Eigen::Vector3d > &)
IGL_INLINE void	getAverageNormal (int, const std::vector< int > &, Eigen::Vector3d &)
IGL_INLINE void	getProjPlane (int, const std::vector< int > &, Eigen::Vector3d &)
IGL_INLINE void	applyMontecarlo (const std::vector< int > &, std::vector< int > *)
IGL_INLINE void	computeCurvature ()
IGL_INLINE void	printCurvature (const std::string &outpath)
IGL_INLINE double	getAverageEdge ()

Static Public Member Functions
static IGL_INLINE int	rotateForward (double *v0, double *v1, double *v2)
static IGL_INLINE void	rotateBackward (int nr, double *v0, double *v1, double *v2)
static IGL_INLINE Eigen::Vector3d	chooseMax (Eigen::Vector3d n, Eigen::Vector3d abc, double ab)

Public Attributes
std::vector< std::vector< double > >	curv
std::vector< std::vector< Eigen::Vector3d > >	curvDir
bool	curvatureComputed
Eigen::MatrixXd	vertices
Eigen::MatrixXi	faces
std::vector< std::vector< int > >	vertex_to_vertices
std::vector< std::vector< int > >	vertex_to_faces
std::vector< std::vector< int > >	vertex_to_faces_index
Eigen::MatrixXd	face_normals
Eigen::MatrixXd	vertex_normals
double	sphereRadius
int	kRing
bool	localMode
bool	projectionPlaneCheck
bool	montecarlo
unsigned int	montecarloN
searchType	st
normalType	nt
double	lastRadius
double	scaledRadius
std::string	lastMeshName
bool	expStep
int	step
int	maxSize

Detailed Description

Constructor & Destructor Documentation

CurvatureCalculator()

IGL_INLINE CurvatureCalculator::CurvatureCalculator

(

)

{
  this->localMode=true;
  this->projectionPlaneCheck=true;
  this->sphereRadius=5;
  this->st=SPHERE_SEARCH;
  this->nt=AVERAGE;
  this->montecarlo=false;
  this->montecarloN=0;
  this->kRing=3;
  this->curvatureComputed=false;
  this->expStep=true;
}

References AVERAGE, curvatureComputed, expStep, kRing, localMode, montecarlo, montecarloN, nt, projectionPlaneCheck, SPHERE_SEARCH, sphereRadius, and st.

Member Function Documentation

applyMontecarlo()

IGL_INLINE void CurvatureCalculator::applyMontecarlo	(	const std::vector< int > &	vin,
		std::vector< int > *	vout
	)

{
  if (montecarloN >= vin.size ())
  {
    *vout = vin;
    return;
  }
 
  float p = ((float) montecarloN) / (float) vin.size();
  for (std::vector<int>::const_iterator vpi = vin.begin(); vpi != vin.end(); ++vpi)
  {
    float r;
    if ((r = ((float)rand () / RAND_MAX)) < p)
    {
      vout->push_back(*vpi);
    }
  }
}

References montecarloN.

Referenced by computeCurvature().

Here is the caller graph for this function:

applyProjOnPlane()

IGL_INLINE void CurvatureCalculator::applyProjOnPlane	(	const Eigen::Vector3d &	ppn,
		const std::vector< int > &	vin,
		std::vector< int > &	vout
	)

{
  for (std::vector<int>::const_iterator vpi = vin.begin(); vpi != vin.end(); ++vpi)
    if (vertex_normals.row(*vpi) * ppn > 0.0)
      vout.push_back(*vpi);
}

References vertex_normals.

Referenced by computeCurvature().

Here is the caller graph for this function:

chooseMax()

static IGL_INLINE Eigen::Vector3d CurvatureCalculator::chooseMax ( Eigen::Vector3d  n, Eigen::Vector3d  abc, double  ab  )

inlinestatic

  {
    int max_i;
    double max_sp;
    Eigen::Vector3d nt[8];
 
    n.normalize ();
    abc.normalize ();
 
    max_sp = - std::numeric_limits<double>::max();
 
    for (int i = 0; i < 4; ++i)
    {
      nt[i] = n;
      if (ab > 0)
      {
        switch (i)
        {
          case 0:
            break;
 
          case 1:
            nt[i][2] = -n[2];
            break;
 
          case 2:
            nt[i][0] = -n[0];
            nt[i][1] = -n[1];
            break;
 
          case 3:
            nt[i][0] = -n[0];
            nt[i][1] = -n[1];
            nt[i][2] = -n[2];
            break;
        }
      }
      else
      {
        switch (i)
        {
          case 0:
            nt[i][0] = -n[0];
            break;
 
          case 1:
            nt[i][1] = -n[1];
            break;
 
          case 2:
            nt[i][0] = -n[0];
            nt[i][2] = -n[2];
            break;
 
          case 3:
            nt[i][1] = -n[1];
            nt[i][2] = -n[2];
            break;
        }
      }
 
      if (nt[i].dot(abc) > max_sp)
      {
        max_sp = nt[i].dot(abc);
        max_i = i;
      }
    }
    return nt[max_i];
  }

References nt.

Referenced by getProjPlane().

Here is the caller graph for this function:

computeCurvature()

IGL_INLINE void CurvatureCalculator::computeCurvature

(

)

{
  //CHECK che esista la mesh
  const size_t vertices_count=vertices.rows();
 
  if (vertices_count ==0)
    return;
 
  curvDir=std::vector< std::vector<Eigen::Vector3d> >(vertices_count);
  curv=std::vector<std::vector<double> >(vertices_count);
 
 
 
  scaledRadius=getAverageEdge()*sphereRadius;
 
  std::vector<int> vv;
  std::vector<int> vvtmp;
  Eigen::Vector3d normal;
 
  //double time_spent;
  //double searchtime=0, ref_time=0, fit_time=0, final_time=0;
 
  for (size_t i=0; i<vertices_count; ++i)
  {
    vv.clear();
    vvtmp.clear();
    Eigen::Vector3d me=vertices.row(i);
    switch (st)
    {
      case SPHERE_SEARCH:
        getSphere(i,scaledRadius,vv,6);
        break;
      case K_RING_SEARCH:
        getKRing(i,kRing,vv);
        break;
      default:
        fprintf(stderr,"Error: search type not recognized");
        return;
    }
 
    if (vv.size()<6)
    {
      std::cerr << "Could not compute curvature of radius " << scaledRadius << std::endl;
      return;
    }
 
 
    if (projectionPlaneCheck)
    {
      vvtmp.reserve (vv.size ());
      applyProjOnPlane (vertex_normals.row(i), vv, vvtmp);
      if (vvtmp.size() >= 6 && vvtmp.size()<vv.size())
        vv = vvtmp;
    }
 
 
    switch (nt)
    {
      case AVERAGE:
        getAverageNormal(i,vv,normal);
        break;
      case PROJ_PLANE:
        getProjPlane(i,vv,normal);
        break;
      default:
        fprintf(stderr,"Error: normal type not recognized");
        return;
    }
    if (vv.size()<6)
    {
      std::cerr << "Could not compute curvature of radius " << scaledRadius << std::endl;
      return;
    }
    if (montecarlo)
    {
      if(montecarloN<6)
        break;
      vvtmp.reserve(vv.size());
      applyMontecarlo(vv,&vvtmp);
      vv=vvtmp;
    }
 
    if (vv.size()<6)
      return;
    std::vector<Eigen::Vector3d> ref(3);
    computeReferenceFrame(i,normal,ref);
 
    Quadric q;
    fitQuadric (me, ref, vv, &q);
    finalEigenStuff(i,ref,q);
  }
 
  lastRadius=sphereRadius;
  curvatureComputed=true;
}

References applyMontecarlo(), applyProjOnPlane(), AVERAGE, computeReferenceFrame(), curv, curvatureComputed, curvDir, finalEigenStuff(), fitQuadric(), getAverageEdge(), getAverageNormal(), getKRing(), getProjPlane(), getSphere(), K_RING_SEARCH, kRing, lastRadius, montecarlo, montecarloN, nt, PROJ_PLANE, projectionPlaneCheck, scaledRadius, SPHERE_SEARCH, sphereRadius, st, vertex_normals, and vertices.

Referenced by igl::principal_curvature().

Here is the call graph for this function:

Here is the caller graph for this function:

computeReferenceFrame()

IGL_INLINE void CurvatureCalculator::computeReferenceFrame	(	int	i,
		const Eigen::Vector3d &	normal,
		std::vector< Eigen::Vector3d > &	ref
	)

{
 
  Eigen::Vector3d longest_v=Eigen::Vector3d(vertices.row(vertex_to_vertices[i][0]));
 
  longest_v=(project(vertices.row(i),longest_v,normal)-Eigen::Vector3d(vertices.row(i))).normalized();
 
  /* L'ultimo asse si ottiene come prodotto vettoriale tra i due
   * calcolati */
  Eigen::Vector3d y_axis=(normal.cross(longest_v)).normalized();
  ref[0]=longest_v;
  ref[1]=y_axis;
  ref[2]=normal;
}

References project(), vertex_to_vertices, and vertices.

Referenced by computeCurvature().

Here is the call graph for this function:

Here is the caller graph for this function:

finalEigenStuff()

IGL_INLINE void CurvatureCalculator::finalEigenStuff	(	int	i,
		const std::vector< Eigen::Vector3d > &	ref,
		Quadric &	q
	)

{
 
  const double a = q.a();
  const double b = q.b();
  const double c = q.c();
  const double d = q.d();
  const double e = q.e();
 
//  if (fabs(a) < 10e-8 || fabs(b) < 10e-8)
//  {
//    std::cout << "Degenerate quadric: " << i << std::endl;
//  }
 
  double E = 1.0 + d*d;
  double F = d*e;
  double G = 1.0 + e*e;
 
  Eigen::Vector3d n = Eigen::Vector3d(-d,-e,1.0).normalized();
 
  double L = 2.0 * a * n[2];
  double M = b * n[2];
  double N = 2 * c * n[2];
 
 
  // ----------------- Eigen stuff
  Eigen::Matrix2d m;
  m << L*G - M*F, M*E-L*F, M*E-L*F, N*E-M*F;
  m = m / (E*G-F*F);
  Eigen::SelfAdjointEigenSolver<Eigen::Matrix2d> eig(m);
 
  Eigen::Vector2d c_val = eig.eigenvalues();
  Eigen::Matrix2d c_vec = eig.eigenvectors();
 
  // std::cerr << "c_val:" << c_val << std::endl;
  // std::cerr << "c_vec:" << c_vec << std::endl;
 
  // std::cerr << "c_vec:" << c_vec(0) << " "  << c_vec(1) << std::endl;
 
  c_val = -c_val;
 
  Eigen::Vector3d v1, v2;
  v1[0] = c_vec(0);
  v1[1] = c_vec(1);
  v1[2] = 0; //d * v1[0] + e * v1[1];
 
  v2[0] = c_vec(2);
  v2[1] = c_vec(3);
  v2[2] = 0; //d * v2[0] + e * v2[1];
 
 
  // v1 = v1.normalized();
  // v2 = v2.normalized();
 
  Eigen::Vector3d v1global = ref[0] * v1[0] + ref[1] * v1[1] + ref[2] * v1[2];
  Eigen::Vector3d v2global = ref[0] * v2[0] + ref[1] * v2[1] + ref[2] * v2[2];
 
  v1global.normalize();
  v2global.normalize();
 
  v1global *= c_val(0);
  v2global *= c_val(1);
 
  if (c_val[0] > c_val[1])
  {
    curv[i]=std::vector<double>(2);
    curv[i][0]=c_val(1);
    curv[i][1]=c_val(0);
    curvDir[i]=std::vector<Eigen::Vector3d>(2);
    curvDir[i][0]=v2global;
    curvDir[i][1]=v1global;
  }
  else
  {
    curv[i]=std::vector<double>(2);
    curv[i][0]=c_val(0);
    curv[i][1]=c_val(1);
    curvDir[i]=std::vector<Eigen::Vector3d>(2);
    curvDir[i][0]=v1global;
    curvDir[i][1]=v2global;
  }
  // ---- end Eigen stuff
}

References CurvatureCalculator::Quadric::a(), CurvatureCalculator::Quadric::b(), CurvatureCalculator::Quadric::c(), curv, curvDir, CurvatureCalculator::Quadric::d(), CurvatureCalculator::Quadric::e(), Eigen::SelfAdjointEigenSolver< _MatrixType >::eigenvalues(), Eigen::SelfAdjointEigenSolver< _MatrixType >::eigenvectors(), and L.

Referenced by computeCurvature().

Here is the call graph for this function:

Here is the caller graph for this function:

fitQuadric()

IGL_INLINE void CurvatureCalculator::fitQuadric	(	const Eigen::Vector3d &	v,
		const std::vector< Eigen::Vector3d > &	ref,
		const std::vector< int > &	vv,
		Quadric *	q
	)

{
  std::vector<Eigen::Vector3d> points;
  points.reserve (vv.size());
 
  for (unsigned int i = 0; i < vv.size(); ++i) {
 
    Eigen::Vector3d  cp = vertices.row(vv[i]);
 
    // vtang non e` il v tangente!!!
    Eigen::Vector3d  vTang = cp - v;
 
    double x = vTang.dot(ref[0]);
    double y = vTang.dot(ref[1]);
    double z = vTang.dot(ref[2]);
    points.push_back(Eigen::Vector3d (x,y,z));
  }
  if (points.size() < 5)
  {
    std::cerr << "ASSERT FAILED! fit function requires at least 5 points: Only " << points.size() << " were given." << std::endl;
    *q = Quadric(0,0,0,0,0);
  }
  else
  {
    *q = Quadric::fit (points);
  }
}

References CurvatureCalculator::Quadric::fit(), and vertices.

Referenced by computeCurvature().

Here is the call graph for this function:

Here is the caller graph for this function:

getAverageEdge()

IGL_INLINE double CurvatureCalculator::getAverageEdge

(

)

{
  double sum = 0;
  int count = 0;
 
  for (int i = 0; i<faces.rows(); ++i)
  {
    for (short unsigned j=0; j<3; ++j)
    {
      Eigen::Vector3d p1=vertices.row(faces.row(i)[j]);
      Eigen::Vector3d p2=vertices.row(faces.row(i)[(j+1)%3]);
 
      double l = (p1-p2).norm();
 
      sum+=l;
      ++count;
    }
  }
 
  return (sum/(double)count);
}

References faces, and vertices.

Referenced by computeCurvature().

Here is the caller graph for this function:

getAverageNormal()

IGL_INLINE void CurvatureCalculator::getAverageNormal	(	int	j,
		const std::vector< int > &	vv,
		Eigen::Vector3d &	normal
	)

{
  normal=(vertex_normals.row(j)).normalized();
  if (localMode)
    return;
 
  for (unsigned int i=0; i<vv.size(); ++i)
  {
    normal+=vertex_normals.row(vv[i]).normalized();
  }
  normal.normalize();
}

References localMode, and vertex_normals.

Referenced by computeCurvature().

Here is the caller graph for this function:

getKRing()

IGL_INLINE void CurvatureCalculator::getKRing	(	const int	start,
		const double	r,
		std::vector< int > &	vv
	)

{
  int bufsize=vertices.rows();
  vv.reserve(bufsize);
  std::list<std::pair<int,int> > queue;
  bool* visited = (bool*)calloc(bufsize,sizeof(bool));
  queue.push_back(std::pair<int,int>(start,0));
  visited[start]=true;
  while (!queue.empty())
  {
    int toVisit=queue.front().first;
    int distance=queue.front().second;
    queue.pop_front();
    vv.push_back(toVisit);
    if (distance<(int)r)
    {
      for (unsigned int i=0; i<vertex_to_vertices[toVisit].size(); ++i)
      {
        int neighbor=vertex_to_vertices[toVisit][i];
        if (!visited[neighbor])
        {
          queue.push_back(std::pair<int,int> (neighbor,distance+1));
          visited[neighbor]=true;
        }
      }
    }
  }
  free(visited);
  return;
}

References free(), vertex_to_vertices, and vertices.

Referenced by computeCurvature().

Here is the call graph for this function:

Here is the caller graph for this function:

getProjPlane()

IGL_INLINE void CurvatureCalculator::getProjPlane	(	int	j,
		const std::vector< int > &	vv,
		Eigen::Vector3d &	ppn
	)

{
  int nr;
  double a, b, c;
  double nx, ny, nz;
  double abcq;
 
  a = b = c = 0;
 
  if (localMode)
  {
    for (unsigned int i=0; i<vertex_to_faces.at(j).size(); ++i)
    {
      Eigen::Vector3d faceNormal=face_normals.row(vertex_to_faces.at(j).at(i));
      a += faceNormal[0];
      b += faceNormal[1];
      c += faceNormal[2];
    }
  }
  else
  {
    for (unsigned int i=0; i<vv.size(); ++i)
    {
      a+= vertex_normals.row(vv[i])[0];
      b+= vertex_normals.row(vv[i])[1];
      c+= vertex_normals.row(vv[i])[2];
    }
  }
  nr = rotateForward (&a, &b, &c);
  abcq = a*a + b*b + c*c;
  nx = sqrt (a*a / abcq);
  ny = sqrt (b*b / abcq);
  nz = sqrt (1 - nx*nx - ny*ny);
  rotateBackward (nr, &a, &b, &c);
  rotateBackward (nr, &nx, &ny, &nz);
 
  ppn = chooseMax (Eigen::Vector3d(nx, ny, nz), Eigen::Vector3d (a, b, c), a * b);
  ppn.normalize();
}

References chooseMax(), face_normals, localMode, rotateBackward(), rotateForward(), sqrt(), vertex_normals, and vertex_to_faces.

Referenced by computeCurvature().

Here is the call graph for this function:

Here is the caller graph for this function:

getSphere()

IGL_INLINE void CurvatureCalculator::getSphere	(	const int	start,
		const double	r,
		std::vector< int > &	vv,
		int	min
	)

{
  int bufsize=vertices.rows();
  vv.reserve(bufsize);
  std::list<int>* queue= new std::list<int>();
  bool* visited = (bool*)calloc(bufsize,sizeof(bool));
  queue->push_back(start);
  visited[start]=true;
  Eigen::Vector3d me=vertices.row(start);
  std::priority_queue<std::pair<int, double>, std::vector<std::pair<int, double> >, comparer >* extra_candidates= new  std::priority_queue<std::pair<int, double>, std::vector<std::pair<int, double> >, comparer >();
  while (!queue->empty())
  {
    int toVisit=queue->front();
    queue->pop_front();
    vv.push_back(toVisit);
    for (unsigned int i=0; i<vertex_to_vertices[toVisit].size(); ++i)
    {
      int neighbor=vertex_to_vertices[toVisit][i];
      if (!visited[neighbor])
      {
        Eigen::Vector3d neigh=vertices.row(neighbor);
        double distance=(me-neigh).norm();
        if (distance<r)
          queue->push_back(neighbor);
        else if ((int)vv.size()<min)
          extra_candidates->push(std::pair<int,double>(neighbor,distance));
        visited[neighbor]=true;
      }
    }
  }
  while (!extra_candidates->empty() && (int)vv.size()<min)
  {
    std::pair<int, double> cand=extra_candidates->top();
    extra_candidates->pop();
    vv.push_back(cand.first);
    for (unsigned int i=0; i<vertex_to_vertices[cand.first].size(); ++i)
    {
      int neighbor=vertex_to_vertices[cand.first][i];
      if (!visited[neighbor])
      {
        Eigen::Vector3d neigh=vertices.row(neighbor);
        double distance=(me-neigh).norm();
        extra_candidates->push(std::pair<int,double>(neighbor,distance));
        visited[neighbor]=true;
      }
    }
  }
  free(extra_candidates);
  free(queue);
  free(visited);
}

References free(), vertex_to_vertices, and vertices.

Referenced by computeCurvature().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

IGL_INLINE void CurvatureCalculator::init	(	const Eigen::MatrixXd &	V,
		const Eigen::MatrixXi &	F
	)

{
  // Normalize vertices
  vertices = V;
 
//  vertices = vertices.array() - vertices.minCoeff();
//  vertices = vertices.array() / vertices.maxCoeff();
//  vertices = vertices.array() * (1.0/igl::avg_edge_length(V,F));
 
  faces = F;
  igl::adjacency_list(F, vertex_to_vertices);
  igl::vertex_triangle_adjacency(V, F, vertex_to_faces, vertex_to_faces_index);
  igl::per_face_normals(V, F, face_normals);
  igl::per_vertex_normals(V, F, face_normals, vertex_normals);
}

References igl::adjacency_list(), face_normals, faces, igl::per_face_normals(), igl::per_vertex_normals(), vertex_normals, vertex_to_faces, vertex_to_faces_index, vertex_to_vertices, igl::vertex_triangle_adjacency(), and vertices.

Referenced by igl::principal_curvature().

Here is the call graph for this function:

Here is the caller graph for this function:

printCurvature()

IGL_INLINE void CurvatureCalculator::printCurvature

(

const std::string &

outpath

)

{
  using namespace std;
  if (!curvatureComputed)
    return;
 
  std::ofstream of;
  of.open(outpath.c_str());
 
  if (!of)
  {
    fprintf(stderr, "Error: could not open output file %s\n", outpath.c_str());
    return;
  }
 
  int vertices_count=vertices.rows();
  of << vertices_count << endl;
  for (int i=0; i<vertices_count; ++i)
  {
    of << curv[i][0] << " " << curv[i][1] << " " << curvDir[i][0][0] << " " << curvDir[i][0][1] << " " << curvDir[i][0][2] << " " <<
    curvDir[i][1][0] << " " << curvDir[i][1][1] << " " << curvDir[i][1][2] << endl;
  }
 
  of.close();
 
}

References curv, curvatureComputed, curvDir, and vertices.

project()

IGL_INLINE Eigen::Vector3d CurvatureCalculator::project	(	const Eigen::Vector3d &	v,
		const Eigen::Vector3d &	vp,
		const Eigen::Vector3d &	ppn
	)

{
  return (vp - (ppn * ((vp - v).dot(ppn))));
}

Referenced by computeReferenceFrame().

Here is the caller graph for this function:

rotateBackward()

static IGL_INLINE void CurvatureCalculator::rotateBackward ( int  nr, double *  v0, double *  v1, double *  v2  )

inlinestatic

  {
    double t;
 
    if (nr == 0)
      return;
 
    t = *v2;
    *v2 = *v0;
    *v0 = *v1;
    *v1 = t;
 
    rotateBackward (nr - 1, v0, v1, v2);
  }

References rotateBackward().

Referenced by getProjPlane(), and rotateBackward().

Here is the call graph for this function:

Here is the caller graph for this function:

rotateForward()

static IGL_INLINE int CurvatureCalculator::rotateForward ( double *  v0, double *  v1, double *  v2  )

inlinestatic

  {
    double t;
 
    if (std::abs(*v2) >= std::abs(*v1) && std::abs(*v2) >= std::abs(*v0))
      return 0;
 
    t = *v0;
    *v0 = *v2;
    *v2 = *v1;
    *v1 = t;
 
    return 1 + rotateForward (v0, v1, v2);
  }

References rotateForward().

Referenced by getProjPlane(), and rotateForward().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

curv

std::vector< std::vector<double> > CurvatureCalculator::curv

Referenced by computeCurvature(), finalEigenStuff(), igl::principal_curvature(), and printCurvature().

curvatureComputed

bool CurvatureCalculator::curvatureComputed

Referenced by CurvatureCalculator(), computeCurvature(), and printCurvature().

curvDir

std::vector< std::vector<Eigen::Vector3d> > CurvatureCalculator::curvDir

Referenced by computeCurvature(), finalEigenStuff(), igl::principal_curvature(), and printCurvature().

expStep

bool CurvatureCalculator::expStep

Referenced by CurvatureCalculator().

face_normals

Eigen::MatrixXd CurvatureCalculator::face_normals

Referenced by getProjPlane(), and init().

faces

Eigen::MatrixXi CurvatureCalculator::faces

Referenced by getAverageEdge(), and init().

kRing

int CurvatureCalculator::kRing

Referenced by CurvatureCalculator(), computeCurvature(), and igl::principal_curvature().

lastMeshName

std::string CurvatureCalculator::lastMeshName

lastRadius

double CurvatureCalculator::lastRadius

Referenced by computeCurvature().

localMode

bool CurvatureCalculator::localMode

Referenced by CurvatureCalculator(), getAverageNormal(), and getProjPlane().

maxSize

int CurvatureCalculator::maxSize

montecarlo

bool CurvatureCalculator::montecarlo

Referenced by CurvatureCalculator(), and computeCurvature().

montecarloN

unsigned int CurvatureCalculator::montecarloN

Referenced by CurvatureCalculator(), applyMontecarlo(), and computeCurvature().

nt

normalType CurvatureCalculator::nt

Referenced by CurvatureCalculator(), chooseMax(), and computeCurvature().

projectionPlaneCheck

bool CurvatureCalculator::projectionPlaneCheck

Referenced by CurvatureCalculator(), and computeCurvature().

scaledRadius

double CurvatureCalculator::scaledRadius

Referenced by computeCurvature().

sphereRadius

double CurvatureCalculator::sphereRadius

Referenced by CurvatureCalculator(), computeCurvature(), and igl::principal_curvature().

st

searchType CurvatureCalculator::st

Referenced by CurvatureCalculator(), computeCurvature(), and igl::principal_curvature().

step

int CurvatureCalculator::step

vertex_normals

Eigen::MatrixXd CurvatureCalculator::vertex_normals

Referenced by applyProjOnPlane(), computeCurvature(), getAverageNormal(), getProjPlane(), and init().

vertex_to_faces

std::vector<std::vector<int> > CurvatureCalculator::vertex_to_faces

Referenced by getProjPlane(), and init().

vertex_to_faces_index

std::vector<std::vector<int> > CurvatureCalculator::vertex_to_faces_index

Referenced by init().

vertex_to_vertices

std::vector<std::vector<int> > CurvatureCalculator::vertex_to_vertices

Referenced by computeReferenceFrame(), getKRing(), getSphere(), and init().

vertices

Eigen::MatrixXd CurvatureCalculator::vertices

Referenced by computeCurvature(), computeReferenceFrame(), fitQuadric(), getAverageEdge(), getKRing(), getSphere(), init(), and printCurvature().

---

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

• src/libigl/igl/principal_curvature.cpp