PowerMap.h

 
#pragma once
 
#if defined(PowerMap_RECURSES)
#error Recursive header files inclusion detected in PowerMap.h
#else // defined(PowerMap_RECURSES)
#define PowerMap_RECURSES
 
#if !defined PowerMap_h
#define PowerMap_h
 
// Inclusions
#include <iostream>
#include <utility>
#include <vector>
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/images/ImageContainerBySTLVector.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
#include "DGtal/images/CConstImage.h"
#include "DGtal/images/CImage.h"
#include "DGtal/geometry/volumes/distance/CPowerSeparableMetric.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
 
namespace DGtal
{
 
  // template class PowerMap
  template < typename TWeightImage,
             typename TPowerSeparableMetric,
             typename TImageContainer =
             ImageContainerBySTLVector<HyperRectDomain<typename TWeightImage::Domain::Space>,
                                       typename TWeightImage::Domain::Space::Vector> >
  class PowerMap
  {
 
  public:
 
    BOOST_CONCEPT_ASSERT(( concepts::CImage< TImageContainer > ));
    BOOST_CONCEPT_ASSERT(( concepts::CConstImage< TWeightImage > ));
    BOOST_CONCEPT_ASSERT(( concepts::CPowerSeparableMetric<TPowerSeparableMetric> ));
 
    typedef TWeightImage WeightImage;
    typedef typename TWeightImage::Value Weight;
    typedef typename WeightImage::Domain::Space Space;
    typedef typename Space::Vector Vector;
    typedef typename Space::Point Point;
    typedef typename Space::Dimension Dimension;
    typedef typename Space::Size Size;
    typedef typename Space::Point::Coordinate Abscissa;
 
    //ImageContainer::Domain::Space must match with TSpace
    BOOST_STATIC_ASSERT ((boost::is_same< typename TWeightImage::Domain::Space,
                          typename TImageContainer::Domain::Space >::value ));
 
    //ImageContainer value type must be  TSpace::Vector
    BOOST_STATIC_ASSERT ((boost::is_same< typename TWeightImage::Domain::Space::Vector,
                          typename TImageContainer::Value >::value ));
 
    //ImageContainer domain type must be  HyperRectangular
    BOOST_STATIC_ASSERT ((boost::is_same< HyperRectDomain<typename TWeightImage::Domain::Space>,
                          typename TImageContainer::Domain >::value ));
 
    typedef typename TImageContainer::Domain Domain;
 
    typedef TPowerSeparableMetric PowerSeparableMetric;
 
    typedef TImageContainer OutputImage;
 
    typedef Vector Value;
    typedef typename OutputImage::ConstRange  ConstRange;
 
    typedef PowerMap<TWeightImage, TPowerSeparableMetric, TImageContainer> Self;
 
    typedef std::array< bool, Space::dimension > PeriodicitySpec;
 
    PowerMap(ConstAlias<Domain> aDomain,
             ConstAlias<WeightImage> aWeightImage,
             ConstAlias<PowerSeparableMetric> aMetric);
 
    PowerMap(ConstAlias<Domain> aDomain,
             ConstAlias<WeightImage> aWeightImage,
             ConstAlias<PowerSeparableMetric> aMetric,
             PeriodicitySpec const & aPeriodicitySpec);
 
    PowerMap() = delete;
 
    ~PowerMap() = default;
 
  public:
    // ------------------- ConstImage model ------------------------
 
    Self &  operator=(const Self &aOtherPowerMap ) = default;
 
    const Domain &  domain() const
    {
      return *myDomainPtr;
    }
 
 
    ConstRange constRange() const
    {
      return myImagePtr->constRange();
    }
 
    Value operator()(const Point &aPoint) const
    {
      return myImagePtr->operator()(aPoint);
    }
 
    const PowerSeparableMetric* metricPtr() const
    {
      return myMetricPtr;
    }
 
    const WeightImage* weightImagePtr() const
    {
      return myWeightImagePtr;
    }
 
    PeriodicitySpec const & getPeriodicitySpec() const
      {
        return myPeriodicitySpec;
      }
 
    inline
    bool isPeriodic( const Dimension n ) const
      {
        return myPeriodicitySpec[ n ];
      }
 
    Point projectPoint( Point aPoint ) const;
 
    void selfDisplay ( std::ostream & out ) const;
 
    // ------------------- Private functions ------------------------
  private:
 
    void compute ( ) ;
 
 
    void computeOtherSteps(const Dimension dim) const;
 
    void computeOtherStep1D (const Point &row,
                             const Dimension dim) const;
 
    Point projectPoint( Point aPoint, const Dimension aMaxDim ) const;
 
    typename Point::Coordinate projectCoordinate( typename Point::Coordinate aCoordinate, const Dimension aDim ) const;
 
    // ------------------- protected methods ------------------------
  protected:
 
 
 
    // ------------------- Private members ------------------------
  private:
 
    const Domain * myDomainPtr;
 
    Point myLowerBoundCopy;
 
    Point myUpperBoundCopy;
 
    Point myInfinity;
 
    std::vector< Dimension > myPeriodicityIndex; // Could be boost::static_vector but it needs Boost >= 1.54.
 
    Point myDomainExtent;
 
  protected:
    const PowerSeparableMetric * myMetricPtr;
 
    CountedPtr<OutputImage> myImagePtr;
 
    const WeightImage * myWeightImagePtr;
 
    PeriodicitySpec myPeriodicitySpec;
 
  }; // end of class PowerMap
 
  template <typename W,
            typename Sep,
            typename Image>
  std::ostream&
  operator<< ( std::ostream & out, const PowerMap<W,Sep,Image> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/volumes/distance/PowerMap.ih"
 
//                                                                           //
 
#endif // !defined PowerMap_h
 
#undef PowerMap_RECURSES
#endif // else defined(PowerMap_RECURSES)