ShapeGeometricFunctors.h

 
#pragma once
 
#if defined(ShapeGeometricFunctors_RECURSES)
#error Recursive header files inclusion detected in ShapeGeometricFunctors.h
#else // defined(ShapeGeometricFunctors_RECURSES)
#define ShapeGeometricFunctors_RECURSES
 
#if !defined ShapeGeometricFunctors_h
#define ShapeGeometricFunctors_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
 
namespace DGtal
{
  namespace functors
  {
    
  namespace ShapeGeometricFunctors 
  {
 
    template <typename TShape>
    struct ShapePositionFunctor {
      typedef TShape Shape;
      typedef typename Shape::RealPoint RealPoint;
      typedef RealPoint Argument;
      typedef RealPoint Quantity;
      typedef Quantity Value;
     
      ShapePositionFunctor( ConstAlias<Shape> aShape = 0 ) : myShape( aShape ) {}
      
      void attach( ConstAlias<Shape> aShape )
      {
        myShape = aShape;
      }
 
      Quantity operator()( const RealPoint & p ) const
      {
        return p;
      }
 
    private:
      CountedConstPtrOrConstPtr<Shape> myShape;
    };
 
    template <typename TShape>
    struct ShapeNormalVectorFunctor {
      typedef TShape Shape;
      typedef typename Shape::RealPoint RealPoint;
      typedef typename Shape::RealVector RealVector;
      typedef RealPoint Argument;
      typedef typename RealVector::Component Scalar;
      typedef RealVector Quantity;
      typedef Quantity Value;
 
      ShapeNormalVectorFunctor( ConstAlias<Shape> aShape = 0 ) : myShape( aShape ) {}
      
      void attach( ConstAlias<Shape> aShape )
      {
        myShape = aShape;
      }
 
      Quantity operator()( const RealPoint & p ) const
      {
        RealVector v = myShape->gradient( p );
        Scalar norm = v.norm();
        return ( norm != 0 ) ? v / norm : v;
      }
 
    private:
      CountedConstPtrOrConstPtr<Shape> myShape;
    };
 
 
    template <typename TShape>
    struct ShapeMeanCurvatureFunctor {
      typedef TShape Shape;
      typedef typename Shape::RealPoint RealPoint;
      typedef typename Shape::RealVector RealVector;
      typedef typename RealVector::Component Scalar;
      typedef RealPoint Argument;
      typedef Scalar Quantity;
      typedef Quantity Value;
      
      ShapeMeanCurvatureFunctor( ConstAlias<Shape> aShape = 0 ) : myShape( aShape ) {}
      
      void attach( ConstAlias<Shape> aShape )
      {
        myShape = aShape;
      }
 
      Quantity operator()( const RealPoint & p ) const
      {
        return myShape->meanCurvature( p );
      }
 
    private:
      CountedConstPtrOrConstPtr<Shape> myShape;
    };
 
    template <typename TShape>
    struct ShapeGaussianCurvatureFunctor {
      typedef TShape Shape;
      typedef typename Shape::RealPoint RealPoint;
      typedef typename Shape::RealVector RealVector;
      typedef typename RealVector::Component Scalar;
      typedef RealPoint Argument;
      typedef Scalar Quantity;
      typedef Quantity Value;
      
      ShapeGaussianCurvatureFunctor( ConstAlias<Shape> aShape = 0 ) : myShape( aShape ) {}
      
      void attach( ConstAlias<Shape> aShape )
      {
        myShape = aShape;
      }
 
      Quantity operator()( const RealPoint & p ) const
      {
        return myShape->gaussianCurvature( p );
      }
 
    private:
      CountedConstPtrOrConstPtr<Shape> myShape;
    };
 
    template <typename TShape>
    struct ShapeFirstPrincipalCurvatureFunctor {
      typedef TShape Shape;
      typedef typename Shape::RealPoint RealPoint;
      typedef typename Shape::RealVector RealVector;
      typedef typename RealVector::Component Scalar;
      typedef RealPoint Argument;
      typedef Scalar Quantity;
      typedef Quantity Value;
      
      ShapeFirstPrincipalCurvatureFunctor( ConstAlias<Shape> aShape = 0 )
        : myShape( aShape ) {}
      
      void attach( ConstAlias<Shape> aShape )
      {
        myShape = aShape;
      }
 
      Quantity operator()( const RealPoint & p ) const
      {
        Quantity k1, k2;
        myShape->principalCurvatures( p, k1, k2 );
        return k1;
      }
 
    private:
      CountedConstPtrOrConstPtr<Shape> myShape;
    }; // struct ShapeFirstPrincipalCurvatureFunctor
    
    template <typename TShape>
    struct ShapeSecondPrincipalCurvatureFunctor {
      typedef TShape Shape;
      typedef typename Shape::RealPoint RealPoint;
      typedef typename Shape::RealVector RealVector;
      typedef typename RealVector::Component Scalar;
      typedef RealPoint Argument;
      typedef Scalar Quantity;
      typedef Quantity Value;
      
      ShapeSecondPrincipalCurvatureFunctor( ConstAlias<Shape> aShape = 0 )
        : myShape( aShape ) {}
      
      void attach( ConstAlias<Shape> aShape )
      {
        myShape = aShape;
      }
 
      Quantity operator()( const RealPoint & p ) const
      {
        Quantity k1, k2;
        myShape->principalCurvatures( p, k1, k2 );
        return k2;
      }
 
    private:
      CountedConstPtrOrConstPtr<Shape> myShape;
    }; // struct ShapeSecondPrincipalCurvatureFunctor
 
    template <typename TShape>
    struct ShapeFirstPrincipalDirectionFunctor {
      typedef TShape Shape;
      typedef typename Shape::RealPoint RealPoint;
      typedef typename Shape::RealVector RealVector;
      typedef typename RealVector::Component Scalar;
      typedef RealPoint Argument;
      typedef RealVector Quantity;
      typedef Quantity Value;
      
      ShapeFirstPrincipalDirectionFunctor( ConstAlias<Shape> aShape = 0 )
        : myShape( aShape ) {}
      
      void attach( ConstAlias<Shape> aShape )
      {
        myShape = aShape;
      }
 
      Quantity operator()( const RealPoint & p ) const
      {
        Quantity d1, d2;
        myShape->principalDirections( p, d1, d2 );
        return d1;
      }
 
    private:
      CountedConstPtrOrConstPtr<Shape> myShape;
    }; // struct ShapeFirstPrincipalDirectionFunctor
 
    template <typename TShape>
    struct ShapeSecondPrincipalDirectionFunctor {
      typedef TShape Shape;
      typedef typename Shape::RealPoint RealPoint;
      typedef typename Shape::RealVector RealVector;
      typedef typename RealVector::Component Scalar;
      typedef RealPoint Argument;
      typedef RealVector Quantity;
      typedef Quantity Value;
      
      ShapeSecondPrincipalDirectionFunctor( ConstAlias<Shape> aShape = 0 )
        : myShape( aShape ) {}
      
      void attach( ConstAlias<Shape> aShape )
      {
        myShape = aShape;
      }
 
      Quantity operator()( const RealPoint & p ) const
      {
        Quantity d1, d2;
        myShape->principalDirections( p, d1, d2 );
        return d2;
      }
 
    private:
      CountedConstPtrOrConstPtr<Shape> myShape;
    }; // struct ShapeSecondPrincipalDirectionFunctor
 
    template <typename TShape>
    struct ShapePrincipalCurvaturesAndDirectionsFunctor {
      typedef TShape Shape;
      typedef typename Shape::RealPoint RealPoint;
      typedef typename Shape::RealVector RealVector;
      typedef typename RealVector::Component Scalar;
      typedef RealPoint Argument;
      typedef std::tuple<Scalar,Scalar,RealVector,RealVector> Quantity;
      typedef Quantity Value;
      
      ShapePrincipalCurvaturesAndDirectionsFunctor( ConstAlias<Shape> aShape = 0 )
        : myShape( aShape ) {}
      
      void attach( ConstAlias<Shape> aShape )
      {
        myShape = aShape;
      }
 
      Quantity operator()( const RealPoint & p ) const
      {
        Scalar k1, k2;
        RealVector d1, d2;
        myShape->principalCurvatures( p, k1, k2 );
        myShape->principalDirections( p, d1, d2 );
        return std::make_tuple( k1, k2, d1, d2 );
      }
 
    private:
      CountedConstPtrOrConstPtr<Shape> myShape;
    }; // struct ShapePrincipalCurvaturesAndDirectionsFunctor
 
    
  } // namespace ShapeGeometricFunctors
  } // namespace functors
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/shapes/ShapeGeometricFunctors.ih"
 
//                                                                           //
 
#endif // !defined ShapeGeometricFunctors_h
 
#undef ShapeGeometricFunctors_RECURSES
#endif // else defined(ShapeGeometricFunctors_RECURSES)