CorrectedNormalCurrentComputer.h

 
#pragma once
 
#if defined(CorrectedNormalCurrentComputer_RECURSES)
#error Recursive header files inclusion detected in CorrectedNormalCurrentComputer.h
#else // defined(CorrectedNormalCurrentComputer_RECURSES)
#define CorrectedNormalCurrentComputer_RECURSES
 
#if !defined CorrectedNormalCurrentComputer_h
#define CorrectedNormalCurrentComputer_h
 
// Inclusions
#include "DGtal/base/Common.h"
#include "DGtal/math/linalg/EigenDecomposition.h"
#include "DGtal/geometry/meshes/SurfaceMeshMeasure.h"
#include "DGtal/geometry/meshes/CorrectedNormalCurrentFormula.h"
#include "DGtal/shapes/SurfaceMesh.h"
 
 
namespace DGtal
{
  // template class CorrectedNormalCurrentComputer
  template < typename TRealPoint, typename TRealVector >
  struct CorrectedNormalCurrentComputer
  {
    typedef TRealPoint                                   RealPoint;
    typedef TRealVector                                  RealVector;
    typedef CorrectedNormalCurrentComputer< RealPoint, RealVector > Self;
    static const Dimension dimension = RealPoint::dimension;
    BOOST_STATIC_ASSERT( ( dimension == 3 ) );
    typedef DGtal::SurfaceMesh< RealPoint, RealVector >  SurfaceMesh;
    typedef typename RealVector::Component               Scalar;
    typedef SimpleMatrix< Scalar, dimension, dimension > RealTensor;
    typedef CorrectedNormalCurrentFormula< RealPoint, RealVector > Formula;
    typedef SurfaceMeshMeasure< RealPoint, RealVector, Scalar >     ScalarMeasure;
    typedef SurfaceMeshMeasure< RealPoint, RealVector, RealTensor > TensorMeasure;
    typedef std::vector< Scalar >                        Scalars;
    typedef std::vector< RealPoint >                     RealPoints;
    typedef std::vector< RealVector >                    RealVectors;
    typedef std::vector< RealTensor >                    RealTensors;
    typedef typename SurfaceMesh::Size                   Size; 
    typedef typename SurfaceMesh::Index                  Index;
    typedef typename SurfaceMesh::Vertex                 Vertex;
    typedef typename SurfaceMesh::Face                   Face;
 
 
    CorrectedNormalCurrentComputer( ConstAlias< SurfaceMesh > aMesh,
                                    bool unit_u = false );
 
    ScalarMeasure computeMu0() const;
    ScalarMeasure computeMu1() const;
    ScalarMeasure computeMu2() const;
    TensorMeasure computeMuXY() const;
 
    //-------------------------------------------------------------------------
  public:
 
    static
    Scalar meanCurvature( Scalar mu0, Scalar mu1 )
    {
      return ( mu0 != 0.0 ) ? mu1 / ( 2.0 * mu0 ) : 0.0;
    }
 
    static
    Scalar GaussianCurvature( Scalar mu0, Scalar mu2 )
    {
      return ( mu0 != 0.0 ) ? mu2 / mu0 : 0.0;
    }
 
    static
    std::tuple< Scalar, Scalar, RealVector, RealVector >
    principalCurvatures( Scalar mu0, RealTensor muXY, const RealVector& N ) 
    {
      muXY += muXY.transpose();
      muXY *= 0.5;
      const double   coef_N = 1000.0 * mu0;
      // Trick to force orthogonality to normal vector.
      // (see @cite lachaud2020interpolated, section 2) 
      for ( int j = 0; j < 3; j++ )
        for ( int k = 0; k < 3; k++ )
          muXY( j, k ) += coef_N * N[ j ] * N[ k ];
      RealTensor V;
      RealVector L;
      EigenDecomposition< 3, double>::getEigenDecomposition( muXY, V, L );
      return std::make_tuple( ( mu0 != 0.0 ) ? -L[ 1 ] / mu0 : 0.0,
                              ( mu0 != 0.0 ) ? -L[ 0 ] / mu0 : 0.0,
                              V.column( 1 ),
                              V.column( 0 ) );
    }    
 
    // ------------------------- Public Datas ------------------------------
  public:
    
    // ------------------------- Protected Datas ------------------------------
  protected:
    
    const SurfaceMesh& myMesh;
    bool myUnitU;
    
    // ------------------------- Private Datas --------------------------------
  private:
 
    // ------------------------- Internals ------------------------------------
  protected:
 
    ScalarMeasure computeMu0ConstantU() const;
    ScalarMeasure computeMu1ConstantU() const;
    ScalarMeasure computeMu2ConstantU() const;
    TensorMeasure computeMuXYConstantU() const;
 
    ScalarMeasure computeMu0InterpolatedU() const;
    ScalarMeasure computeMu1InterpolatedU() const;
    ScalarMeasure computeMu2InterpolatedU() const;
    TensorMeasure computeMuXYInterpolatedU() const;
    
    
  }; // end of class CorrectedNormalCurrentComputer
    
} // namespace DGtal
 
// Includes inline functions.
#include "CorrectedNormalCurrentComputer.ih"
//                                                                           //
 
#endif // !defined CorrectedNormalCurrentComputer_h
 
#undef CorrectedNormalCurrentComputer_RECURSES
#endif // else defined(CorrectedNormalCurrentComputer_RECURSES)