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)