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 "DGtal/base/Common.h"
#include "DGtal/base/CountedPtr.h"
#include "DGtal/images/ImageContainerBySTLVector.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_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;


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

    ~VoronoiMap();

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

    Self &  operator=(const Self &aOtherVoronoiMap );

    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;
    }

    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;

    // ------------------- protected methods ------------------------
  protected:

    VoronoiMap();


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

    const Domain * myDomainPtr;

    const PointPredicate * myPointPredicatePtr;

    Point myLowerBoundCopy;

    Point myUpperBoundCopy;

    Point myInfinity;

  protected:

    const SeparableMetric * myMetricPtr;

    CountedPtr<OutputImage> myImagePtr;

  }; // 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)