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)