VoronoiMapComplete.h

 
#pragma once
 
#if defined(VoronoiMapComplete_RECURSES)
#error Recursive header files inclusion detected in VoronoiMapComplete.h
#else // defined(VoronoiMapComplete_RECURSES)
#define VoronoiMapComplete_RECURSES
 
#if !defined VoronoiMapComplete_h
#define VoronoiMapComplete_h
 
// Inclusions
#include <iostream>
#include <vector>
#include <array>
#include <set>
#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 VoronoiMapComplete
  template < typename TSpace,
             typename TPointPredicate,
             typename TSeparableMetric,
             typename TImageContainer =
             ImageContainerBySTLVector<HyperRectDomain<TSpace>,
                                       std::set<typename TSpace::Vector> >
             >
  class VoronoiMapComplete
  {
 
  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  std::vector<TSpace::Vector>
    BOOST_STATIC_ASSERT ((boost::is_same< std::set<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 typename OutputImage::Value Value;
 
    typedef typename OutputImage::ConstRange  ConstRange;
 
    typedef VoronoiMapComplete< TSpace, TPointPredicate,
                        TSeparableMetric,TImageContainer > Self;
 
 
    typedef std::array< bool, Space::dimension > PeriodicitySpec;
 
    VoronoiMapComplete(ConstAlias<Domain> aDomain,
                       ConstAlias<PointPredicate> predicate,
                       ConstAlias<SeparableMetric> aMetric);
 
    VoronoiMapComplete(ConstAlias<Domain> aDomain,
                       ConstAlias<PointPredicate> predicate,
                       ConstAlias<SeparableMetric> aMetric,
                       PeriodicitySpec const & aPeriodicitySpec);
    ~VoronoiMapComplete() = default;
 
     VoronoiMapComplete() = 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 VoronoiMapComplete
 
  template <typename S, typename P,
            typename Sep, typename TI>
  std::ostream&
  operator<< ( std::ostream & out, const VoronoiMapComplete<S,P,Sep,TI> & object );
 
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/volumes/distance/VoronoiMapComplete.ih"
 
//                                                                           //
 
#endif // !defined VoronoiMap_h
 
#undef VoronoiMapComplete_RECURSES
#endif // else defined(VoronoiMapComplete_RECURSES)