DGtal::PolygonalCalculus< TRealPoint, TRealVector > Class Template Reference

Implements differential operators on polygonal surfaces from [45]. More...

#include <DGtal/dec/PolygonalCalculus.h>

Inheritance diagram for DGtal::PolygonalCalculus< TRealPoint, TRealVector >:

Public Types
typedef PolygonalCalculus< TRealPoint, TRealVector >	Self
	Self type.
typedef SurfaceMesh< TRealPoint, TRealVector >	MySurfaceMesh
	Type of SurfaceMesh.
typedef MySurfaceMesh::Vertex	Vertex
	Vertex type.
typedef MySurfaceMesh::Face	Face
	Face type.
typedef MySurfaceMesh::RealPoint	Real3dPoint
	Position type.
typedef MySurfaceMesh::RealVector	Real3dVector
	Real vector type.
typedef EigenLinearAlgebraBackend	LinAlg
	Linear Algebra Backend from Eigen.
typedef LinAlg::DenseVector	Vector
	Type of Vector.
typedef Vector	Form
	Global 0-form, 1-form, 2-form are Vector.
typedef LinAlg::DenseMatrix	DenseMatrix
	Type of dense matrix.
typedef LinAlg::SparseMatrix	SparseMatrix
	Type of sparse matrix.
typedef LinAlg::Triplet	Triplet
	Type of sparse matrix triplet.
typedef LinAlg::SolverSimplicialLDLT	Solver
	Type of a sparse matrix solver.

Public Member Functions
	BOOST_STATIC_ASSERT ((dimension==3))
Standard services
	PolygonalCalculus (const ConstAlias< MySurfaceMesh > surf, bool globalInternalCacheEnabled=false)
	PolygonalCalculus (const ConstAlias< MySurfaceMesh > surf, const std::function< Real3dPoint(Face, Vertex)> &embedder, bool globalInternalCacheEnabled=false)
	PolygonalCalculus (const ConstAlias< MySurfaceMesh > surf, const std::function< Real3dVector(Vertex)> &embedder, bool globalInternalCacheEnabled=false)
	PolygonalCalculus (const ConstAlias< MySurfaceMesh > surf, const std::function< Real3dPoint(Face, Vertex)> &pos_embedder, const std::function< Vector(Vertex)> &normal_embedder, bool globalInternalCacheEnabled=false)
	PolygonalCalculus ()=delete
	~PolygonalCalculus ()=default
	PolygonalCalculus (const PolygonalCalculus &other)=delete
	PolygonalCalculus (PolygonalCalculus &&other)=delete
PolygonalCalculus &	operator= (const PolygonalCalculus &other)=delete
PolygonalCalculus &	operator= (PolygonalCalculus &&other)=delete
Embedding services
void	setEmbedder (const std::function< Real3dPoint(Face, Vertex)> &externalFunctor)
Per face operators on scalars
DenseMatrix	X (const Face f) const
DenseMatrix	D (const Face f) const
DenseMatrix	E (const Face f) const
DenseMatrix	A (const Face f) const
Vector	vectorArea (const Face f) const
double	faceArea (const Face f) const
Vector	faceNormal (const Face f) const
Real3dVector	faceNormalAsDGtalVector (const Face f) const
DenseMatrix	coGradient (const Face f) const
DenseMatrix	bracket (const Vector &n) const
DenseMatrix	gradient (const Face f) const
DenseMatrix	flat (const Face f) const
DenseMatrix	B (const Face f) const
Vector	centroid (const Face f) const
Real3dPoint	centroidAsDGtalPoint (const Face f) const
DenseMatrix	sharp (const Face f) const
DenseMatrix	P (const Face f) const
DenseMatrix	M (const Face f, const double lambda=1.0) const
DenseMatrix	divergence (const Face f) const
DenseMatrix	curl (const Face f) const
DenseMatrix	laplaceBeltrami (const Face f, const double lambda=1.0) const
Per face operators on vector fields
DenseMatrix	Tv (const Vertex &v) const
DenseMatrix	Tf (const Face &f) const
Vector	toExtrinsicVector (const Vertex v, const Vector &I) const
	toExtrinsicVector
std::vector< Vector >	toExtrinsicVectors (const std::vector< Vector > &I) const
DenseMatrix	Qvf (const Vertex &v, const Face &f) const
DenseMatrix	Rvf (const Vertex &v, const Face &f) const
DenseMatrix	shapeOperator (const Face f) const
DenseMatrix	transportAndFormatVectorField (const Face f, const Vector &uf)
DenseMatrix	covariantGradient (const Face f, const Vector &uf)
DenseMatrix	covariantProjection (const Face f, const Vector &uf)
DenseMatrix	covariantGradient_f (const Face &f) const
DenseMatrix	covariantProjection_f (const Face &f) const
DenseMatrix	connectionLaplacian (const Face &f, double lambda=1.0) const
Global operators
Form	form0 () const
SparseMatrix	identity0 () const
SparseMatrix	globalLaplaceBeltrami (const double lambda=1.0) const
SparseMatrix	globalLumpedMassMatrix () const
SparseMatrix	globalInverseLumpedMassMatrix () const
SparseMatrix	globalConnectionLaplace (const double lambda=1.0) const
SparseMatrix	doubledGlobalLumpedMassMatrix () const
Cache mechanism
std::vector< DenseMatrix >	getOperatorCacheMatrix (const std::function< DenseMatrix(Face)> &perFaceOperator) const
std::vector< Vector >	getOperatorCacheVector (const std::function< Vector(Face)> &perFaceVectorOperator) const
void	enableInternalGlobalCache ()
void	disableInternalGlobalCache ()
Common services
void	init ()
size_t	faceDegree (Face f) const
size_t	nbVertices () const
size_t	nbFaces () const
size_t	degree (const Face f) const
const MySurfaceMesh *	getSurfaceMeshPtr () const
void	selfDisplay (std::ostream &out) const
bool	isValid () const

Static Public Attributes
static const Dimension	dimension = TRealPoint::dimension
	Concept checking.

Private Attributes
const MySurfaceMesh *	mySurfaceMesh
	Underlying SurfaceMesh.
std::function< Real3dPoint(Face, Vertex)>	myEmbedder
	Embedding function (face,vertex)->R^3 for the vertex position wrt. the face.
std::function< Real3dVector(Vertex)>	myVertexNormalEmbedder
	Embedding function (vertex)->R^3 for the vertex normal.
std::vector< size_t >	myFaceDegree
	Cache containing the face degree.
bool	myGlobalCacheEnabled
	Global cache.
std::array< std::unordered_map< Face, DenseMatrix >, 15 >	myGlobalCache

Protected services and types
enum	OPERATOR {   X_ , D_ , E_ , A_ ,   COGRAD_ , GRAD_ , FLAT_ , B_ ,   SHARP_ , P_ , M_ , DIVERGENCE_ ,   CURL_ , L_ , CON_L_ }
	Enum for operators in the internal cache strategy. More...
void	updateFaceDegree ()
	Update the face degree cache.
bool	checkCache (OPERATOR key, const Face f) const
void	setInCache (OPERATOR key, const Face f, const DenseMatrix &ope) const
Vector	computeVertexNormal (const Vertex &v) const
Eigen::Vector3d	n_v (const Vertex &v) const
DenseMatrix	blockConnection (const Face &f) const
DenseMatrix	kroneckerWithI2 (const DenseMatrix &M) const
static Vector	project (const Vector &u, const Vector &n)
static Vector	toVector (const Eigen::Vector3d &x)
	toVector convert Real3dPoint to Eigen::VectorXd
static Eigen::Vector3d	toVec3 (const Real3dPoint &x)
	toVec3 convert Real3dPoint to Eigen::Vector3d
static Real3dVector	toReal3dVector (const Eigen::Vector3d &x)
	toReal3dVector converts Eigen::Vector3d to Real3dVector.

Detailed Description

template<typename TRealPoint, typename TRealVector>
class DGtal::PolygonalCalculus< TRealPoint, TRealVector >

Implements differential operators on polygonal surfaces from [45].

Description of template class 'PolygonalCalculus'

See Discrete differential calculus on polygonal surfaces for details.

Note

The sign convention for the divergence and the Laplacian operator is opposite to the one of [45]. This is to match the usual mathematical convention that the Laplacian (and the Laplacian-Beltrami) has negative eigenvalues (and is the sum of second derivatives in the cartesian grid). It also follows the formal adjointness of exterior derivative and opposite of divergence as relation $\langle \mathrm{d} u, v \rangle = - \langle u, \mathrm{div} v \rangle$. See also https://en.wikipedia.org/wiki/Laplace–Beltrami_operator

Template Parameters

TRealPoint	a model of points $\mathbb{R}^3$ (e.g. PointVector).
TRealVector	a model of vectors in $\mathbb{R}^3$ (e.g. PointVector).

Definition at line 128 of file PolygonalCalculus.h.

Member Typedef Documentation

DenseMatrix

template<typename TRealPoint, typename TRealVector>

typedef LinAlg::DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::DenseMatrix

Type of dense matrix.

Definition at line 158 of file PolygonalCalculus.h.

Face

template<typename TRealPoint, typename TRealVector>

typedef MySurfaceMesh::Face DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Face

Face type.

Definition at line 145 of file PolygonalCalculus.h.

Form

template<typename TRealPoint, typename TRealVector>

typedef Vector DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Form

Global 0-form, 1-form, 2-form are Vector.

Definition at line 156 of file PolygonalCalculus.h.

LinAlg

template<typename TRealPoint, typename TRealVector>

typedef EigenLinearAlgebraBackend DGtal::PolygonalCalculus< TRealPoint, TRealVector >::LinAlg

Linear Algebra Backend from Eigen.

Definition at line 152 of file PolygonalCalculus.h.

MySurfaceMesh

template<typename TRealPoint, typename TRealVector>

typedef SurfaceMesh<TRealPoint, TRealVector> DGtal::PolygonalCalculus< TRealPoint, TRealVector >::MySurfaceMesh

Type of SurfaceMesh.

Definition at line 141 of file PolygonalCalculus.h.

Real3dPoint

template<typename TRealPoint, typename TRealVector>

typedef MySurfaceMesh::RealPoint DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Real3dPoint

Position type.

Definition at line 147 of file PolygonalCalculus.h.

Real3dVector

template<typename TRealPoint, typename TRealVector>

typedef MySurfaceMesh::RealVector DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Real3dVector

Real vector type.

Definition at line 149 of file PolygonalCalculus.h.

Self

template<typename TRealPoint, typename TRealVector>

typedef PolygonalCalculus<TRealPoint, TRealVector> DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Self

Self type.

Definition at line 138 of file PolygonalCalculus.h.

Solver

template<typename TRealPoint, typename TRealVector>

typedef LinAlg::SolverSimplicialLDLT DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Solver

Type of a sparse matrix solver.

Definition at line 165 of file PolygonalCalculus.h.

SparseMatrix

template<typename TRealPoint, typename TRealVector>

typedef LinAlg::SparseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::SparseMatrix

Type of sparse matrix.

Definition at line 160 of file PolygonalCalculus.h.

Triplet

template<typename TRealPoint, typename TRealVector>

typedef LinAlg::Triplet DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Triplet

Type of sparse matrix triplet.

Definition at line 162 of file PolygonalCalculus.h.

Vector

template<typename TRealPoint, typename TRealVector>

typedef LinAlg::DenseVector DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Vector

Type of Vector.

Definition at line 154 of file PolygonalCalculus.h.

Vertex

template<typename TRealPoint, typename TRealVector>

typedef MySurfaceMesh::Vertex DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Vertex

Vertex type.

Definition at line 143 of file PolygonalCalculus.h.

Member Enumeration Documentation

OPERATOR

template<typename TRealPoint, typename TRealVector>

enum DGtal::PolygonalCalculus::OPERATOR

protected

Enum for operators in the internal cache strategy.

Enumerator
X_
D_
E_
A_
COGRAD_
GRAD_
FLAT_
B_
SHARP_
P_
M_
DIVERGENCE_
CURL_
L_
CON_L_

Definition at line 1126 of file PolygonalCalculus.h.

{ X_, D_, E_, A_, COGRAD_, GRAD_, FLAT_, B_, SHARP_, P_, M_, DIVERGENCE_, CURL_, L_,CON_L_};

Constructor & Destructor Documentation

PolygonalCalculus() [1/7]

template<typename TRealPoint, typename TRealVector>

DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus ( const ConstAlias< MySurfaceMesh > surf, bool globalInternalCacheEnabled = false )

inline

Create a Polygonal DEC structure from a surface mesh (surf) using an default identity embedder.

Parameters

surf	an instance of SurfaceMesh
globalInternalCacheEnabled	enable the internal cache for all operators (default: false)

Definition at line 174 of file PolygonalCalculus.h.

                                                            :
          mySurfaceMesh(&surf),  myGlobalCacheEnabled(globalInternalCacheEnabled)
  {
    myEmbedder =[&](Face f,Vertex v){ (void)f; return mySurfaceMesh->position(v);};
    myVertexNormalEmbedder = [&](Vertex v){ return toReal3dVector(computeVertexNormal(v));};
    init();
  };

PolygonalCalculus() [2/7]

template<typename TRealPoint, typename TRealVector>

DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus ( const ConstAlias< MySurfaceMesh > surf, const std::function< Real3dPoint(Face, Vertex)> & embedder, bool globalInternalCacheEnabled = false )

inline

Create a Polygonal DEC structure from a surface mesh (surf) and an embedder for the vertex position: function with two parameters, a face and a vertex which outputs the embedding in R^3 of the vertex w.r.t. to the face.

Parameters

surf	an instance of SurfaceMesh
embedder	an embedder for the vertex position
globalInternalCacheEnabled	if true, the global operator cache is enabled

Definition at line 189 of file PolygonalCalculus.h.

                                                            :
  mySurfaceMesh(&surf), myEmbedder(embedder), myGlobalCacheEnabled(globalInternalCacheEnabled)
  {
    myVertexNormalEmbedder = [&](Vertex v){ return toReal3dVector(computeVertexNormal(v)); };
    init();
  };

PolygonalCalculus() [3/7]

template<typename TRealPoint, typename TRealVector>

DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus ( const ConstAlias< MySurfaceMesh > surf, const std::function< Real3dVector(Vertex)> & embedder, bool globalInternalCacheEnabled = false )

inline

Create a Polygonal DEC structure from a surface mesh (surf) and an embedder for the vertex normal: function with a vertex as parameter which outputs the embedding in R^3 of the vertex normal.

Parameters

surf	an instance of SurfaceMesh
embedder	an embedder for the vertex position
globalInternalCacheEnabled	if true, the global operator cache is enabled

Definition at line 204 of file PolygonalCalculus.h.

                                                            :
      mySurfaceMesh(&surf), myVertexNormalEmbedder(embedder),
      myGlobalCacheEnabled(globalInternalCacheEnabled)
  {
    myEmbedder = [&](Face f,Vertex v){(void)f; return mySurfaceMesh->position(v); };
    init();
  };

PolygonalCalculus() [4/7]

template<typename TRealPoint, typename TRealVector>

DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus ( const ConstAlias< MySurfaceMesh > surf, const std::function< Real3dPoint(Face, Vertex)> & pos_embedder, const std::function< Vector(Vertex)> & normal_embedder, bool globalInternalCacheEnabled = false )

inline

Create a Polygonal DEC structure from a surface mesh (surf) and an embedder for the vertex position: function with two parameters, a face and a vertex which outputs the embedding in R^3 of the vertex w.r.t. to the face. and an embedder for the vertex normal: function with a vertex as parameter which outputs the embedding in R^3 of the vertex normal.

Parameters

surf	an instance of SurfaceMesh
pos_embedder	an embedder for the position
normal_embedder	an embedder for the position
globalInternalCacheEnabled

Definition at line 224 of file PolygonalCalculus.h.

                                                             :
  mySurfaceMesh(&surf), myEmbedder(pos_embedder),
  myVertexNormalEmbedder(normal_embedder),
  myGlobalCacheEnabled(globalInternalCacheEnabled)
  {
    init();
  };

PolygonalCalculus() [5/7]

template<typename TRealPoint, typename TRealVector>

DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus ( )

delete

Deleted default constructor.

~PolygonalCalculus()

template<typename TRealPoint, typename TRealVector>

DGtal::PolygonalCalculus< TRealPoint, TRealVector >::~PolygonalCalculus ( )

default

Destructor (default).

PolygonalCalculus() [6/7]

template<typename TRealPoint, typename TRealVector>

DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus ( const PolygonalCalculus< TRealPoint, TRealVector > & other )

delete

Deleted copy constructor.

Parameters

other

the object to clone.

PolygonalCalculus() [7/7]

template<typename TRealPoint, typename TRealVector>

DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus ( PolygonalCalculus< TRealPoint, TRealVector > && other )

delete

Deleted move constructor.

Parameters

other

the object to move.

Member Function Documentation

A()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::A ( const Face f ) const

inline

Average operator to average, per edge, its vertex values.

Parameters

f

the face

Returns

a degree x degree matrix

Definition at line 353 of file PolygonalCalculus.h.

  {
    if (checkCache(A_,f))
      return myGlobalCache[A_][f];
    
    const auto nf = myFaceDegree[f];
    DenseMatrix a = DenseMatrix::Zero(nf ,nf);
    for(auto i=0u; i < nf; ++i)
    {
      a(i, (i+1)%nf) = 0.5;
      a(i,i) = 0.5;
    }
 
    setInCache(A_,f,a);
    return a;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::B(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::coGradient(), and TEST_CASE().

B()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::B ( const Face f ) const

inline

Edge mid-point operator of the face.

Parameters

f

the face

Returns

a degree x 3 matrix

Definition at line 475 of file PolygonalCalculus.h.

  {
    if (checkCache(B_,f))
      return myGlobalCache[B_][f];
    DenseMatrix res = A(f) * X(f);
    setInCache(B_,f,res);
    return res;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::sharp().

blockConnection()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::blockConnection ( const Face & f ) const

inlineprotected

Returns

Block Diagonal matrix with Rvf for each vertex v in face f

Definition at line 1240 of file PolygonalCalculus.h.

  {
    auto nf           = degree(f);
    DenseMatrix RU_fO = DenseMatrix::Zero(nf * 2,nf * 2);
    size_t cpt        = 0;
    for (auto v : getSurfaceMeshPtr()->incidentVertices(f))
    {
      auto Rv                               = Rvf(v,f);
      RU_fO.block<2,2>(2 * cpt,2 * cpt) = Rv;
      ++cpt;
    }
    return RU_fO;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantGradient_f(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantProjection_f().

BOOST_STATIC_ASSERT()

template<typename TRealPoint, typename TRealVector>

DGtal::PolygonalCalculus< TRealPoint, TRealVector >::BOOST_STATIC_ASSERT

(

(dimension==3)

)

bracket()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::bracket ( const Vector & n ) const

inline

Return [n] as the 3x3 operator such that [n]q = n x q

Parameters

n

a vector

Definition at line 436 of file PolygonalCalculus.h.

  {
    DenseMatrix brack(3,3);
    brack << 0.0 , -n(2), n(1),
             n(2), 0.0 , -n(0),
            -n(1) , n(0),0.0 ;
    return brack;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::gradient(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Qvf(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::sharp().

centroid()

template<typename TRealPoint, typename TRealVector>

Vector DGtal::PolygonalCalculus< TRealPoint, TRealVector >::centroid ( const Face f ) const

inline

Returns

the centroid of the face

Parameters

f

the face

Definition at line 486 of file PolygonalCalculus.h.

  {
    const auto nf = myFaceDegree[f];
    return 1.0/(double)nf * X(f).transpose() * Vector::Ones(nf);
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::centroidAsDGtalPoint(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::sharp(), and TEST_CASE().

centroidAsDGtalPoint()

template<typename TRealPoint, typename TRealVector>

Real3dPoint DGtal::PolygonalCalculus< TRealPoint, TRealVector >::centroidAsDGtalPoint ( const Face f ) const

inline

Returns

the centroid of the face as a DGtal RealPoint

Parameters

f

the face

Definition at line 494 of file PolygonalCalculus.h.

  {
    const Vector c = centroid(f);
    return {c(0),c(1),c(2)};
  }

Referenced by TEST_CASE().

checkCache()

template<typename TRealPoint, typename TRealVector>

bool DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache ( OPERATOR key, const Face f ) const

inlineprotected

Check internal cache if enabled.

Parameters

key	the operator name
f	the face

Returns

true if the operator "key" for the face f has been computed.

Definition at line 1144 of file PolygonalCalculus.h.

  {
    if (myGlobalCacheEnabled)
      if (myGlobalCache[key].find(f) != myGlobalCache[key].end())
        return true;
    return false;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::A(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::B(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::coGradient(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::connectionLaplacian(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::curl(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::D(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::divergence(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::E(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::flat(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::gradient(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::laplaceBeltrami(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::M(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::P(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::sharp(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::X().

coGradient()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::coGradient ( const Face f ) const

inline

co-Gradient operator of the face

Parameters

f

the face

Returns

a 3 x degree matrix

Definition at line 425 of file PolygonalCalculus.h.

  {
    if (checkCache(COGRAD_,f))
      return myGlobalCache[COGRAD_][f];
    DenseMatrix op = E(f).transpose() * A(f);
    setInCache(COGRAD_, f, op);
    return op;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::gradient(), and TEST_CASE().

computeVertexNormal()

template<typename TRealPoint, typename TRealVector>

Vector DGtal::PolygonalCalculus< TRealPoint, TRealVector >::computeVertexNormal ( const Vertex & v ) const

inlineprotected

Compute the (normalized) normal vector at a Vertex by averaging the adjacent face normal vectors.

Parameters

v	the vertex to compute the normal from

Returns

3D normal vector at vertex v

Definition at line 1207 of file PolygonalCalculus.h.

  {
    Vector n(3);
    n(0) = 0.;
    n(1) = 0.;
    n(2) = 0.;
   /* for (auto f : mySurfaceMesh->incidentFaces(v))
      n += vectorArea(f);
    return n.normalized();
    */
    auto faces = mySurfaceMesh->incidentFaces(v);
    for (auto f : faces)
      n += vectorArea(f);
    
    if (fabs(n.norm() - 0.0) < 0.00001)
    {
      //On non-manifold edges touching the boundary, n may be null.
      trace.warning()<<"[PolygonalCalculus] Trying to compute the normal vector at a boundary vertex incident to pnon-manifold edge, we return a random vector."<<std::endl;
      n << Vector::Random(3);
    }
    n = n.normalized();
    return n;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::PolygonalCalculus(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::PolygonalCalculus().

connectionLaplacian()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::connectionLaplacian ( const Face & f, double lambda = 1.0 ) const

inline

L∇ := -(afG∇tG∇+λP∇tP∇)

Returns

Connection/Vector laplacian at face f

Note

The sign convention for the divergence and the Laplacian operator is opposite to the one of [45]. This is to match the usual mathematical convention that the laplacian (and the Laplacian-Beltrami) has negative eigenvalues (and is the sum of second derivatives in the cartesian grid). It also follows the formal adjointness of exterior derivative and opposite of divergence as relation $\langle \mathrm{d} u, v \rangle = - \langle u, \mathrm{div} v \rangle$. See also https://en.wikipedia.org/wiki/Laplace–Beltrami_operator

Definition at line 810 of file PolygonalCalculus.h.

  {
    if (checkCache(CON_L_,f))
      return myGlobalCache[CON_L_][f];
    DenseMatrix G = covariantGradient_f(f);
    DenseMatrix P = covariantProjection_f(f);
    DenseMatrix L = -(faceArea(f) * G.transpose() * G + lambda * P.transpose() * P);
    setInCache(CON_L_,f,L);
    return L;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::globalConnectionLaplace(), and TEST_CASE().

covariantGradient()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantGradient ( const Face f, const Vector & uf )

inline

Covarient gradient at a face a f of intrinsic vectors uf.

Parameters

uf	list of all intrinsic vectors per vertex concatenated in a column vector
f	the face

Returns

the covariant gradient of the given vector field uf (expressed in corresponding vertex tangent frames), wrt face f

Note

Unlike the rest of the per face operators, the covariant operators need to be applied directly to the restriction of the vector field to the face,

Definition at line 756 of file PolygonalCalculus.h.

  {
    return Tf(f).transpose() * gradient(f) *
           transportAndFormatVectorField(f,uf);
  }

Referenced by TEST_CASE().

covariantGradient_f()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantGradient_f ( const Face & f ) const

inline

Returns

Covariant Gradient Operator, returns the operator that acts on the concatenated vectors. When applied, gives the associated 2x2 matrix in the isomorphic vector form (a b c d)^t to be used in the dirichlet energy (vector laplacian) G∇_f. Used to define the connection Laplacian.

Definition at line 782 of file PolygonalCalculus.h.

  {
    return kroneckerWithI2(Tf(f).transpose() * gradient(f)) * blockConnection(f);
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::connectionLaplacian().

covariantProjection()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantProjection ( const Face f, const Vector & uf )

inline

Compute the covariance projection at a face f of intrinsic vectors uf.

Parameters

uf	list of all intrinsic vectors per vertex concatenated in a column vector
f	the face

Returns

the covariant projection of the given vector field uf ( restricted to face f and expressed in corresponding vertex tangent frames)

Note

Unlike the rest of the per face operators, the covariant operators need to be applied directly to the restriction of the vector field to the face

Definition at line 772 of file PolygonalCalculus.h.

  {
    return P(f) * D(f) * transportAndFormatVectorField(f,uf);
  }

Referenced by TEST_CASE().

covariantProjection_f()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantProjection_f ( const Face & f ) const

inline

Returns

Projection Gradient Operator, returns the operator that acts on the concatenated vectors. When applied, gives the associated nfx2 matrix in the isomorphic vector form (a b c d ...)^t to be used in the dirichlet energy (vector laplacian) P∇_f. Used to define the connection Laplacian.

Definition at line 792 of file PolygonalCalculus.h.

  {
    return kroneckerWithI2(P(f) * D(f)) * blockConnection(f);
    ;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::connectionLaplacian().

curl()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::curl ( const Face f ) const

inline

Curl operator of a one-form (identity matrix).

Parameters

f

the face

Returns

a degree x degree matrix

Definition at line 576 of file PolygonalCalculus.h.

  {
    if (checkCache(CURL_,f))
      return myGlobalCache[CURL_][f];
    
    DenseMatrix op = DenseMatrix::Identity(myFaceDegree[f],myFaceDegree[f]);
 
    setInCache(CURL_,f,op);
    return op;
  }

Referenced by TEST_CASE().

D()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::D ( const Face f ) const

inline

Derivative operator (d_0) of a face.

Parameters

f

the face

Returns

a degree x degree matrix

Definition at line 319 of file PolygonalCalculus.h.

  {
    if (checkCache(D_,f))
      return myGlobalCache[D_][f];
    
    const auto nf = myFaceDegree[f];
    DenseMatrix d = DenseMatrix::Zero(nf ,nf);
    for(auto i=0u; i < nf; ++i)
    {
      d(i,i) = -1.;
      d(i, (i+1)%nf) = 1.;
    }
    
    setInCache(D_,f,d);
    return d;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantProjection(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantProjection_f(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::divergence(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::E(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::laplaceBeltrami(), and TEST_CASE().

degree()

template<typename TRealPoint, typename TRealVector>

size_t DGtal::PolygonalCalculus< TRealPoint, TRealVector >::degree ( const Face f ) const

inline

Returns

the degree of the face f (number of vertices)

Parameters

f

the face

Definition at line 1082 of file PolygonalCalculus.h.

  {
    return myFaceDegree[f];
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::blockConnection(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::globalConnectionLaplace().

disableInternalGlobalCache()

template<typename TRealPoint, typename TRealVector>

void DGtal::PolygonalCalculus< TRealPoint, TRealVector >::disableInternalGlobalCache ( )

inline

Disable the internal global cache for operators. This method will also clean up the

Definition at line 1040 of file PolygonalCalculus.h.

  {
    myGlobalCacheEnabled = false;
    myGlobalCache.clear();
  }

divergence()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::divergence ( const Face f ) const

inline

Divergence operator of a one-form.

Parameters

f

the face

Returns

a degree x degree matrix

Note

The sign convention for the divergence and the Laplacian operator is opposite to the one of [45] . This is to match the usual mathematical convention that the Laplacian (and the Laplacian-Beltrami) has negative eigenvalues (and is the sum of second derivatives in the cartesian grid). It also follows the formal adjointness of exterior derivative and opposite of divergence as relation $\langle \mathrm{d} u, v \rangle = - \langle u, \mathrm{div} v \rangle$. See also https://en.wikipedia.org/wiki/Laplace–Beltrami_operator

Definition at line 562 of file PolygonalCalculus.h.

  {
    if (checkCache(DIVERGENCE_,f))
      return myGlobalCache[DIVERGENCE_][f];
 
    DenseMatrix op = -1.0 * D(f).transpose() * M(f);
    setInCache(DIVERGENCE_,f,op);
    
    return op;
  }

doubledGlobalLumpedMassMatrix()

template<typename TRealPoint, typename TRealVector>

SparseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::doubledGlobalLumpedMassMatrix ( ) const

inline

Compute and returns the global lumped mass matrix tensorized with Id_2 (used for connection laplacian) (diagonal matrix with Max's weights for each vertex). M(2*i,2*i) = ∑_{adjface f} faceArea(f)/degree(f) ; M(2*i+1,2*i+1) = M(2*i,2*i)

Returns

the global lumped mass matrix.

Definition at line 960 of file PolygonalCalculus.h.

  {
    auto nv = mySurfaceMesh->nbVertices();
    SparseMatrix M(2 * nv, 2 * nv);
    std::vector<Triplet> triplets;
    for (typename MySurfaceMesh::Index v = 0; v < mySurfaceMesh->nbVertices(); ++v)
    {
      auto faces = mySurfaceMesh->incidentFaces(v);
      auto varea = 0.0;
      for (auto f : faces)
        varea += faceArea(f) / (double)myFaceDegree[f];
      triplets.emplace_back(Triplet(2 * v, 2 * v, varea));
      triplets.emplace_back(Triplet(2 * v + 1, 2 * v + 1, varea));
    }
    M.setFromTriplets(triplets.begin(), triplets.end());
    return M;
  }

E()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::E ( const Face f ) const

inline

Edge vector operator per face.

Parameters

f

the face

Returns

degree x 3 matrix

Definition at line 339 of file PolygonalCalculus.h.

  {
    if (checkCache(E_,f))
      return myGlobalCache[E_][f];
 
    DenseMatrix op = D(f)*X(f);
 
    setInCache(E_,f,op);
    return op;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::coGradient(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::flat().

enableInternalGlobalCache()

template<typename TRealPoint, typename TRealVector>

void DGtal::PolygonalCalculus< TRealPoint, TRealVector >::enableInternalGlobalCache ( )

inline

Enable the internal global cache for operators.

Definition at line 1033 of file PolygonalCalculus.h.

  {
    myGlobalCacheEnabled = true;
  }

faceArea()

template<typename TRealPoint, typename TRealVector>

double DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceArea ( const Face f ) const

inline

Area of a face from the vector area.

Parameters

f

the face

Returns

the corrected area of the face

Definition at line 398 of file PolygonalCalculus.h.

  {
    return vectorArea(f).norm();
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::connectionLaplacian(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::doubledGlobalLumpedMassMatrix(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::globalLumpedMassMatrix(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::gradient(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::M(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::sharp(), and TEST_CASE().

faceDegree()

template<typename TRealPoint, typename TRealVector>

size_t DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceDegree ( Face f ) const

inline

Helper to retrieve the degree of the face from the cache.

Parameters

f

the face

Returns

the number of vertices of the face.

Definition at line 1063 of file PolygonalCalculus.h.

  {
    return myFaceDegree[f];
  }

Referenced by TEST_CASE().

faceNormal()

template<typename TRealPoint, typename TRealVector>

Vector DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceNormal ( const Face f ) const

inline

Corrected normal vector of a face.

Parameters

f

the face

Returns

a vector (Eigen vector)

Definition at line 406 of file PolygonalCalculus.h.

  {
    Vector v = vectorArea(f);
    v.normalize();
    return v;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::faceNormalAsDGtalVector(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::flat(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::gradient(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Qvf(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::sharp(), TEST_CASE(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Tf().

faceNormalAsDGtalVector()

template<typename TRealPoint, typename TRealVector>

Real3dVector DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceNormalAsDGtalVector ( const Face f ) const

inline

Corrected normal vector of a face.

Parameters

f

the face

Returns

a vector (DGtal RealVector/RealPoint)

Definition at line 416 of file PolygonalCalculus.h.

  {
    Vector v = faceNormal(f);
    return {v(0),v(1),v(2)};
  }

Referenced by TEST_CASE().

flat()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::flat ( const Face f ) const

inline

Flat operator for the face.

Parameters

f

the face

Returns

a degree x 3 matrix

Definition at line 462 of file PolygonalCalculus.h.

  {
    if (checkCache(FLAT_,f))
      return myGlobalCache[FLAT_][f];
    DenseMatrix n = faceNormal(f);
    DenseMatrix op = E(f)*( DenseMatrix::Identity(3,3) - n*n.transpose());
    setInCache(FLAT_,f,op);
    return op;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::P(), and TEST_CASE().

form0()

template<typename TRealPoint, typename TRealVector>

Form DGtal::PolygonalCalculus< TRealPoint, TRealVector >::form0 ( ) const

inline

Returns

a 0-form initialized to zero

Definition at line 828 of file PolygonalCalculus.h.

  {
    return Form::Zero( nbVertices() );
  }

getOperatorCacheMatrix()

template<typename TRealPoint, typename TRealVector>

std::vector< DenseMatrix > DGtal::PolygonalCalculus< TRealPoint, TRealVector >::getOperatorCacheMatrix ( const std::function< DenseMatrix(Face)> & perFaceOperator ) const

inline

Generic method to compute all the per face DenseMatrices and store them in an indexed container.

Usage example:

auto opM = [&](const PolygonalCalculus<Mesh>::Face f){ return calculus.M(f);};
auto cacheM = boxCalculus.getOperatorCacheMatrix(opM);
...
//Now you have access to the cached values and mixed them with un-cached ones
  Face f = ...;
  auto res = cacheM[f] * calculus.D(f) * phi;
 ...

Parameters

perFaceOperator

the per face operator

Returns

an indexed container of all DenseMatrix operators (indexed per Face).

Definition at line 999 of file PolygonalCalculus.h.

  {
    std::vector<DenseMatrix> cache;
    for( typename MySurfaceMesh::Index f=0; f < mySurfaceMesh->nbFaces(); ++f)
      cache.push_back(perFaceOperator(f));
    return cache;
  }

Referenced by TEST_CASE().

getOperatorCacheVector()

template<typename TRealPoint, typename TRealVector>

std::vector< Vector > DGtal::PolygonalCalculus< TRealPoint, TRealVector >::getOperatorCacheVector ( const std::function< Vector(Face)> & perFaceVectorOperator ) const

inline

Generic method to compute all the per face Vector and store them in an indexed container.

Usage example:

auto opCentroid = [&](const PolygonalCalculus<Mesh>::Face f){ return calculus.centroid(f);};
auto cacheCentroid = boxCalculus.getOperatorCacheVector(opCentroid);
...
//Now you have access to the cached values and mixed them with un-cached ones
  Face f = ...;
  auto res = calculus.P(f) * cacheCentroid[f] ;
 ...

Parameters

perFaceVectorOperator

the per face operator

Returns

an indexed container of all Vector quantities (indexed per Face).

Definition at line 1023 of file PolygonalCalculus.h.

  {
    std::vector<Vector> cache;
    for( typename MySurfaceMesh::Index f=0; f < mySurfaceMesh->nbFaces(); ++f)
      cache.push_back(perFaceVectorOperator(f));
    return cache;
  }

Referenced by TEST_CASE().

getSurfaceMeshPtr()

template<typename TRealPoint, typename TRealVector>

const MySurfaceMesh * DGtal::PolygonalCalculus< TRealPoint, TRealVector >::getSurfaceMeshPtr ( ) const

inline

Returns

an pointer to the underlying SurfaceMash object.

Definition at line 1088 of file PolygonalCalculus.h.

  {
    return mySurfaceMesh;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::blockConnection(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Tf(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Tv().

globalConnectionLaplace()

template<typename TRealPoint, typename TRealVector>

SparseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::globalConnectionLaplace ( const double lambda = 1.0 ) const

inline

Computes the global Connection-Laplace-Beltrami operator by accumulating the per face operators.

Parameters

lambda

the regualrization parameter for the local Connection-Laplace-Beltrami operators

Returns

a sparse 2*nbVertices x 2*nbVertices matrix

Note

The sign convention for the divergence is opposite to the one of [45]. This is also true for the Laplacian operator. This is to match the usual mathematical convention that the Laplacian (and the Laplacian-Beltrami) has negative eigenvalues (and is the sum of second derivatives in the cartesian grid). It also follows the formal adjointness of exterior derivative and opposite of divergence as relation $\langle \mathrm{d} u, v \rangle = - \langle u, \mathrm{div} v \rangle$. See also https://en.wikipedia.org/wiki/Laplace–Beltrami_operator

Definition at line 928 of file PolygonalCalculus.h.

  {
    auto nv = mySurfaceMesh->nbVertices();
    SparseMatrix lapGlobal(2 * nv, 2 * nv);
    SparseMatrix local(2 * nv, 2 * nv);
    std::vector<Triplet> triplets;
    for (typename MySurfaceMesh::Index f = 0; f < mySurfaceMesh->nbFaces(); f++)
    {
      auto nf             = degree(f);
      DenseMatrix Lap     = connectionLaplacian(f,lambda);
      const auto vertices = mySurfaceMesh->incidentVertices(f);
      for (auto i = 0u; i < nf; ++i)
        for (auto j = 0u; j < nf; ++j)
          for (short k1 = 0; k1 < 2; k1++)
            for (short k2 = 0; k2 < 2; k2++)
            {
              auto v = Lap(2 * i + k1, 2 * j + k2);
              if (v != 0.0)
                triplets.emplace_back(Triplet(2 * vertices[i] + k1,
                                                2 * vertices[j] + k2, v));
            }
    }
    lapGlobal.setFromTriplets(triplets.begin(), triplets.end());
    return lapGlobal;
  }

globalInverseLumpedMassMatrix()

template<typename TRealPoint, typename TRealVector>

SparseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::globalInverseLumpedMassMatrix ( ) const

inline

Compute and returns the inverse of the global lumped mass matrix (diagonal matrix with Max's weights for each vertex).

Returns

the inverse of the global lumped mass matrix.

Definition at line 902 of file PolygonalCalculus.h.

  {
    SparseMatrix iM0 = globalLumpedMassMatrix();
    for ( int k = 0; k < iM0.outerSize(); ++k )
      for ( typename SparseMatrix::InnerIterator it( iM0, k ); it; ++it )
        it.valueRef() = 1.0 / it.value();
    return iM0;
  }

globalLaplaceBeltrami()

template<typename TRealPoint, typename TRealVector>

SparseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::globalLaplaceBeltrami ( const double lambda = 1.0 ) const

inline

Computes the global Laplace-Beltrami operator by assembling the per face operators.

Parameters

lambda

the regularization parameter for the local Laplace-Beltrami operators

Returns

a sparse nbVertices x nbVertices matrix

Note

The sign convention for the divergence is opposite to the one of [45]. This is also true for the Laplacian operator. This is to match the usual mathematical convention that the Laplacian (and the Laplacian-Beltrami) has negative eigenvalues (and is the sum of second derivatives in the cartesian grid). It also follows the formal adjointness of exterior derivative and opposite of divergence as relation $\langle \mathrm{d} u, v \rangle = - \langle u, \mathrm{div} v \rangle$. See also https://en.wikipedia.org/wiki/Laplace–Beltrami_operator

Definition at line 855 of file PolygonalCalculus.h.

  {
    SparseMatrix lapGlobal(mySurfaceMesh->nbVertices(), mySurfaceMesh->nbVertices());
    std::vector<Triplet> triplets;
    for( typename MySurfaceMesh::Index f = 0; f < mySurfaceMesh->nbFaces(); ++f )
    {
      auto nf = myFaceDegree[f];
      DenseMatrix Lap = this->laplaceBeltrami(f,lambda);
      const auto vertices = mySurfaceMesh->incidentVertices(f);
      for(auto i=0u; i < nf; ++i)
        for(auto j=0u; j < nf; ++j)
        {
          auto v = Lap(i,j);
          if (v!= 0.0)
            triplets.emplace_back( Triplet( (SparseMatrix::StorageIndex)vertices[ i ], (SparseMatrix::StorageIndex)vertices[ j ],
                                            Lap( i, j ) ) );
        }
    }
    lapGlobal.setFromTriplets(triplets.begin(), triplets.end());
    return lapGlobal;
  }

Referenced by TEST_CASE().

globalLumpedMassMatrix()

template<typename TRealPoint, typename TRealVector>

SparseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::globalLumpedMassMatrix ( ) const

inline

Compute and returns the global lumped mass matrix (diagonal matrix with Max's weights for each vertex). M(i,i) = ∑_{adjface f} faceArea(f)/degree(f) ;

Returns

the global lumped mass matrix.

Definition at line 882 of file PolygonalCalculus.h.

  {
    SparseMatrix M(mySurfaceMesh->nbVertices(), mySurfaceMesh->nbVertices());
    std::vector<Triplet> triplets;
    for ( typename MySurfaceMesh::Index v = 0; v < mySurfaceMesh->nbVertices(); ++v )
      {
        auto faces = mySurfaceMesh->incidentFaces(v);
        auto varea = 0.0;
        for(auto f: faces)
          varea += faceArea(f) /(double)myFaceDegree[f];
        triplets.emplace_back(Triplet(v,v,varea));
      }
    M.setFromTriplets(triplets.begin(),triplets.end());
    return M;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::globalInverseLumpedMassMatrix(), and TEST_CASE().

gradient()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::gradient ( const Face f ) const

inline

Gradient operator of the face.

Parameters

f

the face

Returns

3 x degree matrix

Definition at line 448 of file PolygonalCalculus.h.

  {
    if (checkCache(GRAD_,f))
      return myGlobalCache[GRAD_][f];
    
    DenseMatrix op = -1.0/faceArea(f) * bracket( faceNormal(f) ) * coGradient(f);
    
    setInCache(GRAD_,f,op);
    return op;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantGradient(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantGradient_f(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::shapeOperator(), and TEST_CASE().

identity0()

template<typename TRealPoint, typename TRealVector>

SparseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::identity0 ( ) const

inline

Returns

the identity linear operator for 0-forms

Definition at line 833 of file PolygonalCalculus.h.

  {
    SparseMatrix Id0( nbVertices(), nbVertices() );
    Id0.setIdentity();
    return Id0; 
  }

init()

template<typename TRealPoint, typename TRealVector>

void DGtal::PolygonalCalculus< TRealPoint, TRealVector >::init ( )

inline

Update the internal cache structures (e.g. degree of each face).

Definition at line 1055 of file PolygonalCalculus.h.

  {
    updateFaceDegree();
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::PolygonalCalculus(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::PolygonalCalculus(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::PolygonalCalculus(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::PolygonalCalculus().

isValid()

template<typename TRealPoint, typename TRealVector>

bool DGtal::PolygonalCalculus< TRealPoint, TRealVector >::isValid ( ) const

inline

Checks the validity/consistency of the object.

Returns

'true' if the object is valid, 'false' otherwise.

Definition at line 1111 of file PolygonalCalculus.h.

  {
    return true;
  }

Referenced by TEST_CASE().

kroneckerWithI2()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::kroneckerWithI2 ( const DenseMatrix & M ) const

inlineprotected

Returns

the tensor-kronecker product of M with 2x2 identity matrix

Definition at line 1255 of file PolygonalCalculus.h.

  {
    size_t h       = M.rows();
    size_t w       = M.cols();
    DenseMatrix MK = DenseMatrix::Zero(h * 2,w * 2);
    for (size_t j = 0; j < h; j++)
      for (size_t i = 0; i < w; i++)
      {
        MK(2 * j, 2 * i)         = M(j, i);
        MK(2 * j + 1, 2 * i + 1) = M(j, i);
      }
    return MK;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantGradient_f(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantProjection_f().

laplaceBeltrami()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::laplaceBeltrami ( const Face f, const double lambda = 1.0 ) const

inline

(weak) Laplace-Beltrami operator for the face.

Parameters

f	the face
lambda	the regularization parameter

Returns

a degree x degree matrix

Note

The sign convention for the divergence and the Laplacian operator is opposite to the one of [45] . This is to match the usual mathematical convention that the Laplacian (and the Laplacian-Beltrami) has negative eigenvalues (and is the sum of second derivatives in the cartesian grid). It also follows the formal adjointness of exterior derivative and opposite of divergence as relation $\langle \mathrm{d} u, v \rangle = - \langle u, \mathrm{div} v \rangle$. See also https://en.wikipedia.org/wiki/Laplace–Beltrami_operator

Definition at line 602 of file PolygonalCalculus.h.

  {
    if (checkCache(L_,f))
      return myGlobalCache[L_][f];
 
    DenseMatrix Df = D(f);
    // Laplacian is a negative operator.
    DenseMatrix op = -1.0 * Df.transpose() * M(f,lambda) * Df;
    
    setInCache(L_, f, op);
    return op;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::globalLaplaceBeltrami(), and TEST_CASE().

M()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::M ( const Face f, const double lambda = 1.0 ) const

inline

Inner product on 1-forms associated with the face

Parameters

f	the face
lambda	the regularization parameter

Returns

a degree x degree matrix

Definition at line 535 of file PolygonalCalculus.h.

  {
    if (checkCache(M_,f))
      return myGlobalCache[M_][f];
    
    DenseMatrix Uf = sharp(f);
    DenseMatrix Pf = P(f);
    DenseMatrix op = faceArea(f) * Uf.transpose()*Uf + lambda * Pf.transpose()*Pf;
    
    setInCache(M_,f,op);
    return op;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::divergence(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::doubledGlobalLumpedMassMatrix(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::globalLumpedMassMatrix(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::kroneckerWithI2(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::laplaceBeltrami().

n_v()

template<typename TRealPoint, typename TRealVector>

Eigen::Vector3d DGtal::PolygonalCalculus< TRealPoint, TRealVector >::n_v ( const Vertex & v ) const

inlineprotected

Returns

the normal vector at vertex v, if no normal vertex embedder is set, the normal will be computed

Definition at line 1233 of file PolygonalCalculus.h.

  {
    return toVec3(myVertexNormalEmbedder(v));
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Qvf(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::shapeOperator(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Tv().

nbFaces()

template<typename TRealPoint, typename TRealVector>

size_t DGtal::PolygonalCalculus< TRealPoint, TRealVector >::nbFaces ( ) const

inline

Returns

the number of faces of the underlying surface mesh.

Definition at line 1075 of file PolygonalCalculus.h.

  {
    return mySurfaceMesh->nbFaces();
  }

nbVertices()

template<typename TRealPoint, typename TRealVector>

size_t DGtal::PolygonalCalculus< TRealPoint, TRealVector >::nbVertices ( ) const

inline

Returns

the number of vertices of the underlying surface mesh.

Definition at line 1069 of file PolygonalCalculus.h.

  {
    return mySurfaceMesh->nbVertices();
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::form0(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::identity0(), and TEST_CASE().

operator=() [1/2]

template<typename TRealPoint, typename TRealVector>

PolygonalCalculus & DGtal::PolygonalCalculus< TRealPoint, TRealVector >::operator= ( const PolygonalCalculus< TRealPoint, TRealVector > & other )

delete

Deleted copy assignment operator.

Parameters

other

the object to copy.

Returns

a reference on 'this'.

operator=() [2/2]

template<typename TRealPoint, typename TRealVector>

PolygonalCalculus & DGtal::PolygonalCalculus< TRealPoint, TRealVector >::operator= ( PolygonalCalculus< TRealPoint, TRealVector > && other )

delete

Deleted move assignment operator.

Parameters

other

the object to move.

Returns

a reference on 'this'.

P()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::P ( const Face f ) const

inline

Projection operator for the face.

Parameters

f

the face

Returns

a degree x degree matrix

Definition at line 519 of file PolygonalCalculus.h.

  {
    if (checkCache(P_,f))
      return myGlobalCache[P_][f];
    
    const auto  nf = myFaceDegree[f];
    DenseMatrix op = DenseMatrix::Identity(nf,nf) - flat(f)*sharp(f);
 
    setInCache(P_, f, op);
    return op;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantProjection(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantProjection_f(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::M(), and TEST_CASE().

project()

template<typename TRealPoint, typename TRealVector>

Vector DGtal::PolygonalCalculus< TRealPoint, TRealVector >::project ( const Vector & u, const Vector & n )

inlinestaticprotected

Project u on the orthgonal of n

Parameters

u	vector to project
n	vector to build orthogonal space from

Returns

projected vector

Definition at line 1167 of file PolygonalCalculus.h.

  {
    return u - (u.dot(n) / n.squaredNorm()) * n;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Tf(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Tv().

Qvf()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Qvf ( const Vertex & v, const Face & f ) const

inline

https://math.stackexchange.com/questions/180418/calculate-rotation-matrix-to-align-vector-a-to-vector-b-in-3d@return 3x3 Rotation matrix to align n_v to n_f

Definition at line 688 of file PolygonalCalculus.h.

  {
    Eigen::Vector3d nf = faceNormal(f);
    Eigen::Vector3d nv = n_v(v);
    double c           = nv.dot(nf);
    ASSERT(std::abs( c + 1.0) > 0.0001);
    //Special case for opposite nv and nf vectors.
    if (std::abs( c + 1.0) < 0.00001)
      return -Eigen::Matrix3d::Identity();
  
    auto vv          = nv.cross(nf);
    DenseMatrix skew = bracket(vv);
    return Eigen::Matrix3d::Identity() + skew +
           1.0 / (1.0 + c) * skew * skew;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Rvf().

Rvf()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Rvf ( const Vertex & v, const Face & f ) const

inline

Returns

Levi-Civita connection from vertex v tangent space to face f tangent space (2x2 rotation matrix)

Definition at line 706 of file PolygonalCalculus.h.

  {
    return Tf(f).transpose() * Qvf(v,f) * Tv(v);
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::blockConnection(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::transportAndFormatVectorField().

selfDisplay()

template<typename TRealPoint, typename TRealVector>

void DGtal::PolygonalCalculus< TRealPoint, TRealVector >::selfDisplay ( std::ostream & out ) const

inline

Writes/Displays the object on an output stream.

Parameters

out	the output stream where the object is written.

Definition at line 1097 of file PolygonalCalculus.h.

  {
    out << "[PolygonalCalculus]: ";
    if (myGlobalCacheEnabled)
      out<< "internal cache enabled, ";
    else
      out<<"internal cache disabled, ";
    out <<"SurfaceMesh="<<*mySurfaceMesh;
  }

setEmbedder()

template<typename TRealPoint, typename TRealVector>

void DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setEmbedder ( const std::function< Real3dPoint(Face, Vertex)> & externalFunctor )

inline

Update the embedding function.

Parameters

externalFunctor

a new embedding functor (Face,Vertex)->RealPoint.

Definition at line 280 of file PolygonalCalculus.h.

  {
    myEmbedder = externalFunctor;
  }

setInCache()

template<typename TRealPoint, typename TRealVector>

void DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache ( OPERATOR key, const Face f, const DenseMatrix & ope ) const

inlineprotected

Set an operator in the internal cache.

Parameters

key	the operator name
f	the face
ope	the operator to store

Definition at line 1156 of file PolygonalCalculus.h.

  {
    if (myGlobalCacheEnabled)
      myGlobalCache[key][f]  = ope;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::A(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::B(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::coGradient(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::connectionLaplacian(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::curl(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::D(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::divergence(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::E(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::flat(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::gradient(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::laplaceBeltrami(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::M(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::P(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::sharp(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::X().

shapeOperator()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::shapeOperator ( const Face f ) const

inline

Shape operator on the face f (2x2 operator).

Returns

the shape operator at face f

Definition at line 713 of file PolygonalCalculus.h.

  {
    DenseMatrix N(myFaceDegree[f],3);
    uint cpt = 0;
    for (Vertex v : mySurfaceMesh->incidentVertices(f))
    {
      N.block(cpt,0,3,1) = n_v(v).transpose();
      cpt++;
    }
    DenseMatrix GN = gradient(f) * N, Tf = T_f(f);
 
    return 0.5 * Tf.transpose() * (GN + GN.transpose()) * Tf;
  }

sharp()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::sharp ( const Face f ) const

inline

Sharp operator for the face.

Parameters

f

the face

Returns

a 3 x degree matrix

Definition at line 503 of file PolygonalCalculus.h.

  {
    if (checkCache(SHARP_,f))
      return myGlobalCache[SHARP_][f];
 
    const auto  nf = myFaceDegree[f];
    DenseMatrix op = 1.0/faceArea(f) * bracket(faceNormal(f)) *
          ( B(f).transpose() - centroid(f)* Vector::Ones(nf).transpose() );
 
    setInCache(SHARP_,f,op);
    return op;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::M(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::P(), and TEST_CASE().

Tf()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Tf ( const Face & f ) const

inline

Returns

3x2 matrix defining the tangent space at face f, with basis vectors in columns

Definition at line 644 of file PolygonalCalculus.h.

  {
    Eigen::Vector3d nf = faceNormal(f);
    ASSERT(std::abs(nf.norm() - 1.0) < 0.001);
    const auto & N = getSurfaceMeshPtr()->incidentVertices(f);
    auto v1        = *(N.begin());
    auto v2        = *(N.begin() + 1);
    Real3dPoint tangentVector =
    getSurfaceMeshPtr()->position(v2) - getSurfaceMeshPtr()->position(v1);
    Eigen::Vector3d w  = toVec3(tangentVector);
    Eigen::Vector3d uu = project(w,nf).normalized();
    Eigen::Vector3d vv = nf.cross(uu);
 
    DenseMatrix tanB(3,2);
    tanB.col(0) = uu;
    tanB.col(1) = vv;
    return tanB;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantGradient(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantGradient_f(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Rvf().

toExtrinsicVector()

template<typename TRealPoint, typename TRealVector>

Vector DGtal::PolygonalCalculus< TRealPoint, TRealVector >::toExtrinsicVector ( const Vertex v, const Vector & I ) const

inline

toExtrinsicVector

Parameters

v	the vertex
I	the intrinsic vector at Tv

Returns

3D extrinsic vector from intrinsic 2D vector I expressed from tangent frame at vertex v

Definition at line 668 of file PolygonalCalculus.h.

  {
    DenseMatrix T = Tv(v);
    return T.col(0) * I(0) + T.col(1) * I(1);
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::toExtrinsicVectors().

toExtrinsicVectors()

template<typename TRealPoint, typename TRealVector>

std::vector< Vector > DGtal::PolygonalCalculus< TRealPoint, TRealVector >::toExtrinsicVectors ( const std::vector< Vector > & I ) const

inline

Parameters

I	set of intrinsic vectors, vectors indices must be the same as their associated vertex

Returns

converts a set of intrinsic vectors to their extrinsic equivalent, expressed in correponding tangent frame

Definition at line 678 of file PolygonalCalculus.h.

  {
    std::vector<Vector> ext(mySurfaceMesh->nbVertices());
    for (auto v = 0; v < mySurfaceMesh->nbVertices(); v++)
      ext[v] = toExtrinsicVector(v,I[v]);
    return ext;
  }

toReal3dVector()

template<typename TRealPoint, typename TRealVector>

Real3dVector DGtal::PolygonalCalculus< TRealPoint, TRealVector >::toReal3dVector ( const Eigen::Vector3d & x )

inlinestaticprotected

toReal3dVector converts Eigen::Vector3d to Real3dVector.

Conversion routines.

Parameters

x	the vector

Returns

the same vector in DGtal type

Definition at line 1196 of file PolygonalCalculus.h.

    {
      return { x(0), x(1), x(2)};
    }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::PolygonalCalculus(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::PolygonalCalculus().

toVec3()

template<typename TRealPoint, typename TRealVector>

Eigen::Vector3d DGtal::PolygonalCalculus< TRealPoint, TRealVector >::toVec3 ( const Real3dPoint & x )

inlinestaticprotected

toVec3 convert Real3dPoint to Eigen::Vector3d

Parameters

x	the vector

Returns

the same vector in eigen type

Definition at line 1187 of file PolygonalCalculus.h.

  {
    return Eigen::Vector3d(x(0),x(1),x(2));
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::n_v(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Tf(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Tv().

toVector()

template<typename TRealPoint, typename TRealVector>

Vector DGtal::PolygonalCalculus< TRealPoint, TRealVector >::toVector ( const Eigen::Vector3d & x )

inlinestaticprotected

toVector convert Real3dPoint to Eigen::VectorXd

Conversion routines.

Parameters

x	the vector

Returns

the same vector in eigen type

Definition at line 1176 of file PolygonalCalculus.h.

  {
    Vector X(3);
    for (int i = 0; i < 3; i++)
      X(i) = x(i);
    return X;
  }

transportAndFormatVectorField()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::transportAndFormatVectorField ( const Face f, const Vector & uf )

inline

Returns

to fit [45] paper's notations, this function maps all the per vertex vectors (expressed in the (2*nf) vector form) into the nfx2 matrix with transported vectors (to face f) in each row.

Note

Unlike the rest of the per face operators, the covariant operators need to be applied directly to the restriction of the vector field to the face,

Definition at line 734 of file PolygonalCalculus.h.

  {
    DenseMatrix uf_nabla(myFaceDegree[f], 2);
    size_t cpt = 0;
    for (auto v : mySurfaceMesh->incidentVertices(f))
    {
      uf_nabla.block(cpt,0,1,2) =
      (Rvf(v,f) * uf.block(2 * cpt,0,2,1)).transpose();
      ++cpt;
    }
    return uf_nabla;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantGradient(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::covariantProjection().

Tv()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Tv ( const Vertex & v ) const

inline

Returns

3x2 matrix defining the tangent space at vertex v, with basis vectors in columns

Definition at line 624 of file PolygonalCalculus.h.

  {
    Eigen::Vector3d nv = n_v(v);
    ASSERT(std::abs(nv.norm() - 1.0) < 0.001);
    const auto & N            = getSurfaceMeshPtr()->neighborVertices(v);
    auto neighbor             = *N.begin();
    Real3dPoint tangentVector = getSurfaceMeshPtr()->position(v) -
                                getSurfaceMeshPtr()->position(neighbor);
    Eigen::Vector3d w  = toVec3(tangentVector);
    Eigen::Vector3d uu = project(w,nv).normalized();
    Eigen::Vector3d vv = nv.cross(uu);
 
    DenseMatrix tanB(3,2);
    tanB.col(0) = uu;
    tanB.col(1) = vv;
    return tanB;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::Rvf(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::toExtrinsicVector().

updateFaceDegree()

template<typename TRealPoint, typename TRealVector>

void DGtal::PolygonalCalculus< TRealPoint, TRealVector >::updateFaceDegree ( )

inlineprotected

Update the face degree cache.

Definition at line 1129 of file PolygonalCalculus.h.

  {
    myFaceDegree.resize(mySurfaceMesh->nbFaces());
    for(typename MySurfaceMesh::Index f = 0; f <  mySurfaceMesh->nbFaces(); ++f)
    {
      auto vertices = mySurfaceMesh->incidentVertices(f);
      auto nf = vertices.size();
      myFaceDegree[f] = nf;
    }
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::init().

vectorArea()

template<typename TRealPoint, typename TRealVector>

Vector DGtal::PolygonalCalculus< TRealPoint, TRealVector >::vectorArea ( const Face f ) const

inline

Polygonal (corrected) vector area.

Parameters

f

the face

Returns

a vector oriented in the (corrected) normal direction and with length equal to the (corrected) area of the face f.

Definition at line 374 of file PolygonalCalculus.h.

  {
    Real3dPoint af(0.0,0.0,0.0);
    const auto vertices = mySurfaceMesh->incidentVertices(f);
    auto it     = vertices.cbegin();
    auto itnext = vertices.cbegin();
    ++itnext;
    while (it != vertices.cend())
    {
      auto xi  = myEmbedder(f,*it);
      auto xip = myEmbedder(f,*itnext);
      af += xi.crossProduct(xip);
      ++it;
      ++itnext;
      if (itnext == vertices.cend())
        itnext = vertices.cbegin();
    }
    Eigen::Vector3d output = {af[0],af[1],af[2]};
    return 0.5*output;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::computeVertexNormal(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::faceArea(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::faceNormal(), and TEST_CASE().

X()

template<typename TRealPoint, typename TRealVector>

DenseMatrix DGtal::PolygonalCalculus< TRealPoint, TRealVector >::X ( const Face f ) const

inline

Return the vertex position matrix degree x 3 of the face.

Parameters

f

a face

Returns

the n_f x 3 position matrix

Definition at line 294 of file PolygonalCalculus.h.

  {
    if (checkCache(X_,f))
      return myGlobalCache[X_][f];
    
    const auto vertices = mySurfaceMesh->incidentVertices(f);
    const auto nf = myFaceDegree[f];
    DenseMatrix Xt(nf,3);
    size_t cpt=0;
    for(auto v: vertices)
    {
      Xt(cpt,0) = myEmbedder(f,v)[0];
      Xt(cpt,1) = myEmbedder(f,v)[1];
      Xt(cpt,2) = myEmbedder(f,v)[2];
      ++cpt;
    }
    
    setInCache(X_,f,Xt);
    return  Xt;
  }

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::B(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::centroid(), DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::E(), TEST_CASE(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::toVector().

Field Documentation

dimension

template<typename TRealPoint, typename TRealVector>

const Dimension DGtal::PolygonalCalculus< TRealPoint, TRealVector >::dimension = TRealPoint::dimension

static

Concept checking.

Definition at line 134 of file PolygonalCalculus.h.

myEmbedder

template<typename TRealPoint, typename TRealVector>

std::function<Real3dPoint(Face, Vertex)> DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myEmbedder

private

Embedding function (face,vertex)->R^3 for the vertex position wrt. the face.

Definition at line 1281 of file PolygonalCalculus.h.

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::vectorArea(), and DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::X().

myFaceDegree

template<typename TRealPoint, typename TRealVector>

std::vector<size_t> DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree

private

Cache containing the face degree.

Definition at line 1287 of file PolygonalCalculus.h.

myGlobalCache

template<typename TRealPoint, typename TRealVector>

std::array<std::unordered_map<Face,DenseMatrix>, 15> DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache

mutableprivate

Definition at line 1291 of file PolygonalCalculus.h.

myGlobalCacheEnabled

template<typename TRealPoint, typename TRealVector>

bool DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCacheEnabled

private

Global cache.

Definition at line 1290 of file PolygonalCalculus.h.

mySurfaceMesh

template<typename TRealPoint, typename TRealVector>

const MySurfaceMesh* DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh

private

Underlying SurfaceMesh.

Definition at line 1278 of file PolygonalCalculus.h.

myVertexNormalEmbedder

template<typename TRealPoint, typename TRealVector>

std::function<Real3dVector(Vertex)> DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myVertexNormalEmbedder

private

Embedding function (vertex)->R^3 for the vertex normal.

Definition at line 1284 of file PolygonalCalculus.h.

Referenced by DGtal::PolygonalCalculus< SH3::RealPoint, SH3::RealVector >::n_v().

---

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

• PolygonalCalculus.h