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

#include <DGtal/dec/PolygonalCalculus.h>

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 >

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 >

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

Face type.

Definition at line 145 of file PolygonalCalculus.h.

◆ Form

template<typename TRealPoint , typename TRealVector >

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 >

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 >

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 >

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

Position type.

Definition at line 147 of file PolygonalCalculus.h.

◆ Real3dVector

template<typename TRealPoint , typename TRealVector >

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

Real vector type.

Definition at line 149 of file PolygonalCalculus.h.

◆ Self

template<typename TRealPoint , typename TRealVector >

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

Self type.

Definition at line 138 of file PolygonalCalculus.h.

◆ Solver

template<typename TRealPoint , typename TRealVector >

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 >

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 >

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 >

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

Type of Vector.

Definition at line 154 of file PolygonalCalculus.h.

◆ Vertex

template<typename TRealPoint , typename TRealVector >

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.

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

DGtal::PolygonalCalculus::P_

@ P_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::E_

@ E_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::M_

@ M_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::X_

@ X_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::B_

@ B_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::A_

@ A_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::SHARP_

@ SHARP_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::DIVERGENCE_

@ DIVERGENCE_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::D_

@ D_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::GRAD_

@ GRAD_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::CURL_

@ CURL_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::FLAT_

@ FLAT_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::L_

@ L_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::CON_L_

@ CON_L_

Definition PolygonalCalculus.h:1126

DGtal::PolygonalCalculus::COGRAD_

@ COGRAD_

Definition PolygonalCalculus.h:1126

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();
  };

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::computeVertexNormal(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::init(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myEmbedder, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myVertexNormalEmbedder, DGtal::SurfaceMesh< TRealPoint, TRealVector >::position(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::toReal3dVector().

◆ 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();
  };

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::computeVertexNormal(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::init(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myVertexNormalEmbedder, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::toReal3dVector().

◆ 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();
  };

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::init(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myEmbedder, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, and DGtal::SurfaceMesh< TRealPoint, TRealVector >::position().

◆ 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();
  };

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::A_, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::B(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::coGradient(), initQuantities(), 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::A(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::B_, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::X().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::degree(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::getSurfaceMeshPtr(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Rvf().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantGradient_f(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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< TRealPoint, TRealVector >::gradient(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Qvf(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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);
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::X().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::centroidAsDGtalPoint(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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)};
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::centroid().

Referenced by initQuantities(), and 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCacheEnabled.

◆ 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::A(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::COGRAD_, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::E(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::gradient(), initQuantities(), initQuantitiesCached(), 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;
  }

References DGtal::SurfaceMesh< TRealPoint, TRealVector >::incidentFaces(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, DGtal::trace, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::vectorArea(), and DGtal::Trace::warning().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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< TRealPoint, TRealVector >::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);
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::gradient(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Tf(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::transportAndFormatVectorField().

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);
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::blockConnection(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::gradient(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::kroneckerWithI2(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Tf().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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);
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::D(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::P(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::transportAndFormatVectorField().

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);
    ;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::blockConnection(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::D(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::kroneckerWithI2(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::P().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::CURL_, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache().

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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::D_, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantProjection(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantProjection_f(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::divergence(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::E(), initQuantities(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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];
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree.

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::blockConnection(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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();
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCacheEnabled.

◆ 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::D(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::DIVERGENCE_, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::M(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache().

◆ 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceArea(), DGtal::SurfaceMesh< TRealPoint, TRealVector >::incidentFaces(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::M(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, and DGtal::SurfaceMesh< TRealPoint, TRealVector >::nbVertices().

◆ 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::D(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::E_, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::X().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::coGradient(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCacheEnabled.

◆ 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();
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::vectorArea().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::connectionLaplacian(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::doubledGlobalLumpedMassMatrix(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::globalLumpedMassMatrix(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::gradient(), initQuantities(), initQuantitiesCached(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::M(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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];
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree.

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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::vectorArea().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceNormalAsDGtalVector(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::flat(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::gradient(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Qvf(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::sharp(), TEST_CASE(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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)};
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceNormal().

Referenced by initQuantities(), initQuantitiesCached(), and 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::E(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceNormal(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::FLAT_, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache().

Referenced by initQuantities(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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() );
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::nbVertices().

Referenced by computeLaplace(), and TEST_CASE().

◆ 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, and DGtal::SurfaceMesh< TRealPoint, TRealVector >::nbFaces().

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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, and DGtal::SurfaceMesh< TRealPoint, TRealVector >::nbFaces().

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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh.

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::blockConnection(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Tf(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::connectionLaplacian(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::degree(), DGtal::SurfaceMesh< TRealPoint, TRealVector >::incidentVertices(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, DGtal::SurfaceMesh< TRealPoint, TRealVector >::nbFaces(), and DGtal::SurfaceMesh< TRealPoint, TRealVector >::nbVertices().

◆ 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::globalLumpedMassMatrix().

◆ 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;
  }

References DGtal::SurfaceMesh< TRealPoint, TRealVector >::incidentVertices(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::laplaceBeltrami(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, DGtal::SurfaceMesh< TRealPoint, TRealVector >::nbFaces(), and DGtal::SurfaceMesh< TRealPoint, TRealVector >::nbVertices().

Referenced by computeLaplace(), TEST_CASE(), and 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceArea(), DGtal::SurfaceMesh< TRealPoint, TRealVector >::incidentFaces(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::M(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, and DGtal::SurfaceMesh< TRealPoint, TRealVector >::nbVertices().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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< TRealPoint, TRealVector >::covariantGradient(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantGradient_f(), initQuantities(), initQuantitiesCached(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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; 
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::nbVertices().

◆ 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();
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::updateFaceDegree().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::M().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantGradient_f(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::D(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::L_, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::M(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceArea(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::M_, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::P(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::sharp().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::divergence(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::doubledGlobalLumpedMassMatrix(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::globalLumpedMassMatrix(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::kroneckerWithI2(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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));
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myVertexNormalEmbedder, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::toVec3().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Qvf(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::shapeOperator(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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();
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, and DGtal::SurfaceMesh< TRealPoint, TRealVector >::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();
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, and DGtal::SurfaceMesh< TRealPoint, TRealVector >::nbVertices().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::form0(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::flat(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::P_, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::sharp().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::connectionLaplacian(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantProjection(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantProjection_f(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::M(), and TEST_CASE().

◆ project()

template<typename TRealPoint , typename TRealVector >

static 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< TRealPoint, TRealVector >::Tf(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::bracket(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceNormal(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::n_v().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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);
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Qvf(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Tf(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Tv().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::blockConnection(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCacheEnabled, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myEmbedder.

Referenced by precompute().

◆ 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCache, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myGlobalCacheEnabled.

◆ 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::gradient(), DGtal::SurfaceMesh< TRealPoint, TRealVector >::incidentVertices(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::n_v(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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 initQuantities(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::M(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::P(), TEST_CASE(), and test_linear_structure().

◆ 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceNormal(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::getSurfaceMeshPtr(), DGtal::SurfaceMesh< TRealPoint, TRealVector >::incidentVertices(), DGtal::SurfaceMesh< TRealPoint, TRealVector >::position(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::project(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::toVec3().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantGradient(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantGradient_f(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Rvf(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::shapeOperator().

◆ 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);
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Tv().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, DGtal::SurfaceMesh< TRealPoint, TRealVector >::nbVertices(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::toExtrinsicVector().

◆ toReal3dVector()

template<typename TRealPoint , typename TRealVector >

static 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< TRealPoint, TRealVector >::PolygonalCalculus(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus().

◆ toVec3()

template<typename TRealPoint , typename TRealVector >

static 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< TRealPoint, TRealVector >::n_v(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Tf(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Tv().

◆ toVector()

template<typename TRealPoint , typename TRealVector >

static 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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::SurfaceMesh< TRealPoint, TRealVector >::incidentVertices(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Rvf().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::covariantGradient(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::PolygonalCalculus< TRealPoint, TRealVector >::getSurfaceMeshPtr(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::n_v(), DGtal::SurfaceMesh< TRealPoint, TRealVector >::neighborVertices(), DGtal::SurfaceMesh< TRealPoint, TRealVector >::position(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::project(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::toVec3().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::Rvf(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
    }
  }

References DGtal::SurfaceMesh< TRealPoint, TRealVector >::incidentVertices(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myFaceDegree, DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh, and DGtal::SurfaceMesh< TRealPoint, TRealVector >::nbFaces().

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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;
  }

References DGtal::SurfaceMesh< TRealPoint, TRealVector >::incidentVertices(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::myEmbedder, and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::mySurfaceMesh.

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::computeVertexNormal(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceArea(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::faceNormal(), initQuantities(), initQuantitiesCached(), 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< TRealPoint, TRealVector >::B(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::centroid(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::E(), TEST_CASE(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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< TRealPoint, TRealVector >::PolygonalCalculus(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setEmbedder(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::vectorArea(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::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.

Referenced by DGtal::PolygonalCalculus< TRealPoint, TRealVector >::checkCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::disableInternalGlobalCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::enableInternalGlobalCache(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::selfDisplay(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::setInCache().

◆ 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< TRealPoint, TRealVector >::n_v(), DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus(), and DGtal::PolygonalCalculus< TRealPoint, TRealVector >::PolygonalCalculus().

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

PolygonalCalculus.h

Public Types

Public Member Functions

Static Public Attributes

Private Attributes

Protected services and types

Detailed Description

Member Typedef Documentation

◆ DenseMatrix

◆ Face

◆ Form

◆ LinAlg

◆ MySurfaceMesh

◆ Real3dPoint

◆ Real3dVector

◆ Self

◆ Solver

◆ SparseMatrix

◆ Triplet

◆ Vector

◆ Vertex

Member Enumeration Documentation

◆ OPERATOR

Constructor & Destructor Documentation

◆ PolygonalCalculus() [1/7]

◆ PolygonalCalculus() [2/7]

◆ PolygonalCalculus() [3/7]

◆ PolygonalCalculus() [4/7]

◆ PolygonalCalculus() [5/7]

◆ ~PolygonalCalculus()

◆ PolygonalCalculus() [6/7]

◆ PolygonalCalculus() [7/7]

Member Function Documentation

◆ A()

◆ B()

◆ blockConnection()

◆ BOOST_STATIC_ASSERT()

◆ bracket()

◆ centroid()

◆ centroidAsDGtalPoint()

◆ checkCache()

◆ coGradient()

◆ computeVertexNormal()

◆ connectionLaplacian()

◆ covariantGradient()

◆ covariantGradient_f()

◆ covariantProjection()

◆ covariantProjection_f()

◆ curl()

◆ D()

◆ degree()

◆ disableInternalGlobalCache()

◆ divergence()

◆ doubledGlobalLumpedMassMatrix()

◆ E()

◆ enableInternalGlobalCache()

◆ faceArea()

◆ faceDegree()

◆ faceNormal()

◆ faceNormalAsDGtalVector()

◆ flat()

◆ form0()

◆ getOperatorCacheMatrix()

◆ getOperatorCacheVector()

◆ getSurfaceMeshPtr()

◆ globalConnectionLaplace()

◆ globalInverseLumpedMassMatrix()

◆ globalLaplaceBeltrami()

◆ globalLumpedMassMatrix()

◆ gradient()

◆ identity0()

◆ init()

◆ isValid()

◆ kroneckerWithI2()

◆ laplaceBeltrami()

◆ M()

◆ n_v()

◆ nbFaces()

◆ nbVertices()

◆ operator=() [1/2]

◆ operator=() [2/2]