FunctorsLambdaMST.h

 
#pragma once

 
#if defined(FunctorsLambdaMST_RECURSES)
#error Recursive header files inclusion detected in FunctorsLambdaMST.h
#else // defined(FunctorsLambdaMST_RECURSES)
#define FunctorsLambdaMST_RECURSES
 
#if !defined FunctorsLambdaMST_h
#define FunctorsLambdaMST_h

// Inclusions
#include <functional>
#include <iterator>
#include  <stdexcept>
#include "DGtal/base/Common.h"
#include "DGtal/base/IteratorCirculatorTraits.h"
#include "DGtal/base/CUnaryFunctor.h"
 
namespace DGtal
{

namespace functors
{
  struct Lambda64Function
  {
      double operator() (double x) const
      {
          double e2 = x * x;
          double e3 = e2 * x;
          return 64.0 * ( -e3 * e3 + 3.0 * e3 * e2 - 3.0 * e2 * e2 + e3 );
      }
  };

  struct LambdaSinFromPiFunction
  {
      double operator() (double x) const
      {
          return std::sin ( M_PI * x );
      }
  };

  struct LambdaExponentialFunction
  {
      double operator() (double x) const
      {
          return 2.0 / ( std::exp ( 15.0 * ( x - 0.5 ) ) + std::exp ( -15.0 * ( x - 0.5 ) ) );
      }
  };
}

template<typename DSS, typename LambdaFunction>
class TangentFromDSS2DFunctor
{
  BOOST_CONCEPT_ASSERT(( concepts::CUnaryFunctor < LambdaFunction, double, double > ));
  // ----------------------- Types ------------------------------
public:
  typedef PointVector<2, double> RealVector;
  typedef DSS TDSS;
 
  struct Value
  {
    RealVector first;
    double second;
    Value () : second ( 0. ) {}
    Value & operator+= ( const Value & ch )
    {
      this->first += ch.first;
      this->second += ch.second;
      return *this;
    }
  };
 
 
  // ----------------------- Interface --------------------------------------
public:
  Value operator() ( const TDSS& aDSS, const int & indexOfPointInDSS, const int & dssLen ) const
  {
    Value result;
    double norm = std::sqrt ( aDSS.a() * aDSS.a() + aDSS.b() * aDSS.b() );
    result.second = lambdaFunctor ( (double)indexOfPointInDSS / (double)dssLen );
    if ( norm > 0. )
    {
      result.first[0] = result.second * aDSS.b() / norm;
      result.first[1] = result.second * aDSS.a() / norm;
    }
    else
    {
      result.first[0] = 0.;
      result.first[1] = 0.;
    }
    return result;
  }
private:
  // ------------------------- Private Data --------------------------------
  LambdaFunction lambdaFunctor;
};

template<typename DSS, typename LambdaFunction>
class TangentFromDSS3DFunctor
{
  BOOST_CONCEPT_ASSERT(( concepts::CUnaryFunctor < LambdaFunction, double, double > ));
public:
  // ----------------------- Types ------------------------------
  typedef PointVector<3, double> RealVector;
  typedef DSS TDSS;
  struct Value
  {
    RealVector first;
    double second;
    Value () : second ( 0. ) {}
    Value & operator += ( const Value & ch )
    {
      this->first += ch.first;
      this->second += ch.second;
      return *this;
    }
  };
 
  // ----------------------- Interface --------------------------------------
  Value operator() ( const TDSS& aDSS, const unsigned int indexOfPointInDSS, const unsigned int dssLen ) const
  {
    Value result;
    typename DSS::Point3d directionZ3;
    RealVector direction;
    typename DSS::PointR3d intercept;
    typename DSS::PointR3d thickness;
 
    aDSS.getParameters ( directionZ3, intercept, thickness );
    direction[0] = directionZ3[0];
    direction[1] = directionZ3[1];
    direction[2] = directionZ3[2];
 
    result.second = lambdaFunctor ( (double)indexOfPointInDSS / (double)dssLen );
 
    double norm = direction.norm();
    if ( norm != 0. )
      direction /= norm;
    result.first = direction * result.second;
    return result;
  }
private:
  // ------------------------- Private Data --------------------------------
  LambdaFunction lambdaFunctor;
};
 

template<typename DSS >
class DSSMuteFilter
{
public:
// ----------------------- Types ------------------------------
  typedef DSS DSSType;
  typedef typename IteratorCirculatorTraits< typename DSSType::ConstIterator >::Value Point;

  bool operator()( const DSSType & ) const
  {
     return false;
  }

  bool admissibility ( const DSSType &, const Point & ) const
  {
    return false;
  }

  long int position ( const DSSType &, const Point & ) const
  {
    throw std::runtime_error ( "You are not suppose to see this error!" );
  }
};
 

template<typename DSS >
class DSSLengthLessEqualFilter
{
public:
// ----------------------- Types ------------------------------
  typedef DSS DSSType;
  typedef typename IteratorCirculatorTraits< typename DSSType::ConstIterator >::Value Point;
 
  DSSLengthLessEqualFilter ( ) : lenThreshold (0), initThreshold ( false ) { }

  void init ( double threshold )
  {
    if ( threshold < 0. )
      throw std::runtime_error ( "The threshold has to be positive!" );
    lenThreshold = threshold;
    initThreshold = true;
  }

  bool operator()( const DSSType & dss ) const
  {
    if (! initThreshold )
      throw std::runtime_error ( "The filter has to be initialized!" );
 
    return std::distance ( dss.begin ( ), dss.end ( ) ) < lenThreshold;
  }

  bool admissibility ( const DSSType & dss, const Point & p ) const
  {
    return ( p - *dss.begin ( ) ).norm ( ) <= lenThreshold || ( p - *( dss.end ( ) - 1 ) ).norm ( ) <= lenThreshold;
  }

  long int position ( const DSSType & dss, const Point & p ) const
  {
    if ( ( p - *dss.begin ( ) ).norm ( ) <= lenThreshold )
      return 1;
    else if ( ( p - *( dss.end ( ) - 1 ) ).norm ( ) <= lenThreshold )
      return std::distance ( dss.begin ( ), dss.end ( ) ) + 1;
    else
      throw std::runtime_error ( "The DSS and the point are not admissible!" );
  }
 
private:
    double lenThreshold;
    bool initThreshold;
};
 
} // namespace DGtal
 
//                                                                           //
 
#endif // !defined FunctorsLambdaMST_h
 
#undef FunctorsLambdaMST_RECURSES
#endif // else defined(FunctorsLambdaMST_RECURSES)