LpMetric.h

 
#pragma once

 
#if defined(LpMetric_RECURSES)
#error Recursive header files inclusion detected in LpMetric.h
#else // defined(LpMetric_RECURSES)
#define LpMetric_RECURSES
 
#if !defined LpMetric_h
#define LpMetric_h

// Inclusions
#include <iostream>
#include <cmath>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/CSpace.h"
#include "DGtal/kernel/CEuclideanRing.h"
 
namespace DGtal
{

// template class LpMetric
  template <typename TSpace>
  class LpMetric
  {
    // ----------------------- Standard services ------------------------------
  public:

    typedef TSpace Space;
    BOOST_CONCEPT_ASSERT(( concepts::CSpace<TSpace> ));

    typedef typename Space::RealPoint Point;
    typedef double Value;
    typedef double RawValue;

    LpMetric( const double anExponent): myExponent(anExponent)
    {}
 

    ~LpMetric()
    {}

    LpMetric ( const LpMetric & other )
    {
      myExponent = other.myExponent;
    }

    LpMetric & operator= ( const LpMetric & other )
    {
      myExponent = other.myExponent;
      return *this;
    }
 
    // ----------------------- Interface --------------------------------------
  public:
 
    // ----------------------- CMetric --------------------------------------
    Value operator()(const Point & aP, const Point &aQ) const
    {
      return std::pow( rawDistance(aP,aQ), 1.0/myExponent);
    }

    RawValue rawDistance(const Point & aP, const Point &aQ) const
    {
      RawValue tmp=0.0;
      for(typename Point::Dimension i = 0; i < aP.size(); ++i)
        tmp += static_cast<RawValue>(std::pow(NumberTraits<typename Point::Coordinate>::castToDouble(std::abs(aP[i] - aQ[i])),
                                              myExponent));
      return tmp;
    }

    Closest closest(const Point &origin,
                    const Point &first,
                    const Point &second) const
    {
      auto dfirst = rawDistance(origin,first);
      auto dsecond = rawDistance(origin,second);
      if (dfirst < dsecond)
        return ClosestFIRST;
      else
        if (dfirst > dsecond)
          return ClosestSECOND;
 
      return ClosestBOTH;
    }

    void selfDisplay ( std::ostream & out ) const
    {
      out << "[LpMetric] Lp Metric exponent=" << myExponent ;
    }

    bool isValid() const
    {
      return true;
    }
 
    // ------------------------- Private Data --------------------------------
  private:

    Value myExponent;
 
  }; // end of class LpMetric

  template <typename T>
  std::ostream&
  operator<< ( std::ostream & out, const LpMetric<T> & object )
  {
    object.selfDisplay( out );
    return out;
  }
 
} // namespace DGtal
 
//                                                                           //
 
#endif // !defined LpMetric_h
 
#undef LpMetric_RECURSES
#endif // else defined(LpMetric_RECURSES)