VoronoiMap.h

#pragma once

#if defined(VoronoiMap_RECURSES)
#error Recursive header files inclusion detected in VoronoiMap.h
#else // defined(VoronoiMap_RECURSES)

#define VoronoiMap_RECURSES

#if !defined VoronoiMap_h

#define VoronoiMap_h

// Inclusions
#include <iostream>
#include <vector>
#include <array>
#include "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/images/ImageContainerBySTLVector.h"
#include "DGtal/images/CImage.h"
#include "DGtal/kernel/CPointPredicate.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
#include "DGtal/geometry/volumes/distance/CSeparableMetric.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
#include "DGtal/base/ConstAlias.h"

namespace DGtal
{

  // template class VoronoiMap
  template < typename TSpace,
             typename TPointPredicate,
             typename TSeparableMetric,
             typename TImageContainer =
             ImageContainerBySTLVector<HyperRectDomain<TSpace>,
                                       typename TSpace::Vector>
             >
  class VoronoiMap
  {

  public:
    BOOST_CONCEPT_ASSERT(( concepts::CSpace< TSpace > ));
    BOOST_CONCEPT_ASSERT(( concepts::CPointPredicate<TPointPredicate> ));
    BOOST_CONCEPT_ASSERT(( concepts::CSeparableMetric<TSeparableMetric> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImage< TImageContainer > ));

    BOOST_STATIC_ASSERT ((boost::is_same< typename TSpace::Point,
                          typename TPointPredicate::Point >::value ));

    //ImageContainer::Domain::Space must match with TSpace
    BOOST_STATIC_ASSERT ((boost::is_same< TSpace,
                          typename TImageContainer::Domain::Space >::value ));

    //ImageContainer value type must be  TSpace::Vector
    BOOST_STATIC_ASSERT ((boost::is_same< typename TSpace::Vector,
                          typename TImageContainer::Value >::value ));

    //ImageContainer domain type must be  HyperRectangular
    BOOST_STATIC_ASSERT ((boost::is_same< HyperRectDomain<TSpace>,
                          typename TImageContainer::Domain >::value ));

    typedef TSpace Space;

    typedef TPointPredicate PointPredicate;

    typedef typename TImageContainer::Domain Domain;

    typedef TSeparableMetric SeparableMetric;

    typedef DGtal::int64_t IntegerLong;

    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;

    typedef TImageContainer OutputImage;

    typedef Vector Value;

    typedef typename OutputImage::ConstRange  ConstRange;

    typedef VoronoiMap< TSpace, TPointPredicate,
                        TSeparableMetric,TImageContainer > Self;


    typedef std::array< bool, Space::dimension > PeriodicitySpec;

    VoronoiMap(ConstAlias<Domain> aDomain,
               ConstAlias<PointPredicate> predicate,
               ConstAlias<SeparableMetric> aMetric);

    VoronoiMap(ConstAlias<Domain> aDomain,
               ConstAlias<PointPredicate> predicate,
               ConstAlias<SeparableMetric> aMetric,
               PeriodicitySpec const & aPeriodicitySpec);
    ~VoronoiMap() = default;

     VoronoiMap() = delete;

  public:
    // ------------------- ConstImage model ------------------------

    Self &  operator=(const Self &aOtherVoronoiMap ) = default;

    const Domain &  domain() const
    {
      return *myDomainPtr;
    }

    ConstRange constRange() const
    {
      return myImagePtr->constRange();
    }

    Value operator()(const Point &aPoint) const
    {
      return myImagePtr->operator()(aPoint);
    }

    const SeparableMetric* metric() const
    {
      return myMetricPtr;
    }

    PeriodicitySpec const & getPeriodicitySpec() const
      {
        return myPeriodicitySpec;
      }

    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;

    typename Point::Coordinate projectCoordinate( typename Point::Coordinate aCoordinate, const Dimension aDim ) const;

    // ------------------- Private members ------------------------
  private:

    const Domain * myDomainPtr;

    const PointPredicate * myPointPredicatePtr;

    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 SeparableMetric * myMetricPtr;

    CountedPtr<OutputImage> myImagePtr;

    PeriodicitySpec myPeriodicitySpec;

  }; // end of class VoronoiMap

  template <typename S, typename P,
            typename Sep, typename TI>
  std::ostream&
  operator<< ( std::ostream & out, const VoronoiMap<S,P,Sep,TI> & object );


} // namespace DGtal


// Includes inline functions.
#include "DGtal/geometry/volumes/distance/VoronoiMap.ih"

//                                                                           //

#endif // !defined VoronoiMap_h

#undef VoronoiMap_RECURSES
#endif // else defined(VoronoiMap_RECURSES)