SeparableMetricAdapter.h

 
#pragma once
 
#if defined(SeparableMetricAdapter_RECURSES)
#error Recursive header files inclusion detected in SeparableMetricAdapter.h
#else // defined(SeparableMetricAdapter_RECURSES)
#define SeparableMetricAdapter_RECURSES
 
#if !defined SeparableMetricAdapter_h
#define SeparableMetricAdapter_h
 
// Inclusions
#include <iostream>
#include <cmath>
#include "DGtal/base/Common.h"
#include "DGtal/geometry/volumes/distance/CMetricSpace.h"
#include "DGtal/base/ConstAlias.h"
 
namespace DGtal
{
 
  // template class SeparableMetricAdapter
  template <typename TMetric>
  class SeparableMetricAdapter
  {
    // ----------------------- Standard services ------------------------------
  public:
 
 
    typedef TMetric Metric;
    BOOST_CONCEPT_ASSERT(( concepts::CMetricSpace<TMetric> ));
 
    typedef typename Metric::Point Point;
    typedef typename Point::Coordinate Abscissa;
    typedef typename Metric::Value Value;
    typedef typename Metric::RawValue RawValue;
    typedef typename Metric::Vector Vector;
    typedef typename Metric::Space Space;
 
    SeparableMetricAdapter(ConstAlias<Metric> aMetric): myMetric(&aMetric)
    {}
 
    ~SeparableMetricAdapter() {};
 
    SeparableMetricAdapter ( const SeparableMetricAdapter &other ) : myMetric(other.myMetric) {}
 
    SeparableMetricAdapter & operator= ( const SeparableMetricAdapter & other )
    {
      myMetric = other.myMetric;
      return *this;
    }
 
    // ----------------------- Interface --------------------------------------
  public:
 
    // ----------------------- CMetric --------------------------------------
    Value operator()(const Point & aP, const Point &aQ) const
    {
      return myMetric->operator()(aP,aQ);
    }
 
    RawValue rawDistance(const Point & aP, const Point &aQ) const
    {
      return myMetric->rawDistance(aP,aQ);
    }
    Closest closest(const Point &origin,
                    const Point &first,
                    const Point &second) const
    {
      return myMetric->closest(origin,first,second);
    }
 
    // ----------------------- CSeparableMetric --------------------------------------
    bool hiddenBy(const Point &u,
                  const Point &v,
                  const Point &w,
                  const Point &startingPoint,
                  const Point &endPoint,
                  const typename Point::UnsignedComponent dim) const;
 
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const
    {
      return myMetric->isValid();
    }
 
 
    Abscissa binarySearchHidden(const Point &u,
                                const Point &v,
                                const typename Point::UnsignedComponent dim,
                                const Point &lower,
                                const Point &upper) const;
 
    // ------------------------- Private methods ------------------------------
  private:
 
    // ------------------------- Private members ------------------------------
  private:
    const Metric *myMetric;
 
  }; // end of class SeparableMetricAdapter
 
 
 
  template <typename TM>
  std::ostream&
  operator<< ( std::ostream & out, const SeparableMetricAdapter<TM> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/volumes/distance/SeparableMetricAdapter.ih"
 
//                                                                           //
 
#endif // !defined SeparableMetricAdapter_h
 
#undef SeparableMetricAdapter_RECURSES
#endif // else defined(SeparableMetricAdapter_RECURSES)