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 "DGtal/base/Common.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 );
    result.first[0] = result.second * aDSS.b () / norm;
    result.first[1] = result.second * aDSS.a () / norm;
    return result;
  }
private:
  // ------------------------- Private Datas --------------------------------
  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 int & indexOfPointInDSS, const int & dssLen ) const
  {
    Value result;
    typename DSS::Point3d directionZ3;
    RealVector direction;
    typename DSS::PointR3d intercept;
    typename DSS::PointR3d thikness;
    
    aDSS.getParameters ( directionZ3, intercept, thikness );
    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 Datas --------------------------------
  LambdaFunction lambdaFunctor;
};

} // namespace DGtal

//                                                                           //

#endif // !defined FunctorsLambdaMST_h

#undef FunctorsLambdaMST_RECURSES
#endif // else defined(FunctorsLambdaMST_RECURSES)