HyperRectDomain_Iterator.h

 
#pragma once

 
#if defined(HyperRectDomain_Iterator_RECURSES)
#error Recursive header files inclusion detected in HyperRectDomain_Iterator.h
#else // defined(HyperRectDomain_Iterator_RECURSES)
#define HyperRectDomain_Iterator_RECURSES
 
#if !defined HyperRectDomain_Iterator_h
#define HyperRectDomain_Iterator_h

// Inclusions
#include <iostream>
#include <vector>
#include <iterator>
#include <type_traits>
 
#include <boost/iterator/iterator_facade.hpp>
 
#include "DGtal/base/Common.h"
 
namespace DGtal
{
  template <typename TIterator>
  class HyperRectDomain_ReverseIterator
    : public boost::iterator_facade <
        HyperRectDomain_ReverseIterator<TIterator>,
        typename TIterator::Point const,
        std::random_access_iterator_tag,
        typename TIterator::Point const&,
        typename std::iterator_traits<TIterator>::difference_type
      >
  {
  public:
    using Iterator = TIterator;
    using Self  = HyperRectDomain_ReverseIterator<Iterator>;
    using Point = typename Iterator::Point;
    using Dimension = typename Point::Dimension;
    using DifferenceType = typename std::iterator_traits<Self>::difference_type; 
 
  public:
    explicit HyperRectDomain_ReverseIterator(Iterator it)
      : current(it)
      , prev(it)
    {
      --prev;
    }
    explicit HyperRectDomain_ReverseIterator(Iterator it) {…}

    const Point& dereference() const
      {
        return *prev;
      }
    const Point& dereference() const {…}

    bool equal( const Self &other ) const
      {
        return current == other.current;
      }
    bool equal( const Self &other ) const {…}

    void increment()
      {
        --current;
        --prev;
      }
    void increment() {…}

    void decrement()
      {
        ++current;
        ++prev;
      }
    void decrement() {…}

    void advance( DifferenceType const& n )
      {
        current -= n;
        prev -= n;
      }
    void advance( DifferenceType const& n ) {…}

    DifferenceType distance_to( const Self& other ) const
      {
        return std::distance(other.current, current);
      }
    DifferenceType distance_to( const Self& other ) const {…}
 
  private:
    Iterator current, prev;
 
  };
  class HyperRectDomain_ReverseIterator {…};

  // class HyperRectDomain_Iterator
  template <typename TPoint>
  class HyperRectDomain_Iterator
    : public boost::iterator_facade <
        HyperRectDomain_Iterator<TPoint>,
        TPoint const,
        std::random_access_iterator_tag,
        TPoint const&,
        typename std::conditional<std::is_same<typename TPoint::Component, BigInteger>::value, BigInteger, std::ptrdiff_t>::type
      >
  {
  public:
    using Point = TPoint;
    using Self  = HyperRectDomain_Iterator<TPoint>;
    using Dimension = typename Point::Dimension;
    using DifferenceType = typename std::iterator_traits<Self>::difference_type; 
 

    HyperRectDomain_Iterator( const Point & p, const Point& lower, const Point &upper )
      : myPoint( p ), mylower( lower ), myupper( upper )
      {
        ASSERT_MSG( // For an empty domain, lower = upper + diag(1) so that begin() == end().
            lower.isLower(upper) || lower == upper + TPoint::diagonal(1),
            "The lower bound must be lower than the upper bound or, for an empty domain, be equal to the upper bound + diagonal(1)."
        );
 
        ASSERT_MSG(
            ( lower.isLower(p) && p.isLower(upper) ) || p == lower || p == upper,
            "The point must be inside the domain or be equal to one of his bound."
        );
 
        // Calculating iterator position in the sequence
        pos = 0;
        DifferenceType delta = 1;
        for ( Dimension i = 0; i < Point::dimension; ++i )
          {
            pos += delta * (myPoint[i] - mylower[i]);
            delta *= myupper[i] - mylower[i] + 1;
          }
      }
    HyperRectDomain_Iterator( const Point & p, const Point& lower, const Point &upper ) {…}
 
  private:
    friend class boost::iterator_core_access;

    const Point& dereference() const
      {
        ASSERT_MSG( // we must be between [begin,end]
            mylower.isLower(myPoint) && myPoint.isLower(myupper),
            "The iterator points outside the domain."
        );
 
        return myPoint;
 
      }
    const Point& dereference() const {…}

    bool equal( const Self &other ) const
      {
        ASSERT_MSG( // we should only compare iterators on the same domain
            mylower == other.mylower && myupper == other.myupper,
            "The compared iterators iterate on different domains."
        );
 
        return pos == other.pos;
      }
    bool equal( const Self &other ) const {…}

    void increment()
      {
        ++pos;
        ++myPoint[0];
        for ( Dimension i = 0; myPoint[i] > myupper[i] && i < Point::dimension - 1; ++i )
          {
            ++myPoint[i+1];
            myPoint[i] = mylower[i];
          }
      }
    void increment() {…}

    void decrement()
      {
        --pos;
        --myPoint[0];
        for ( Dimension i = 0; myPoint[i] < mylower[i] && i < Point::dimension - 1; ++i )
          {
            --myPoint[i+1];
            myPoint[i] = myupper[i];
          }
      }
    void decrement() {…}

    void advance( DifferenceType const& n )
      {
        pos += n;
        if (n > 0)
          {
            myPoint[0] += n;
            for ( Dimension i = 0; myPoint[i] > myupper[i] && i < Point::dimension - 1; ++i )
              {
                typename Point::Component const shift = myPoint[i] - mylower[i];
                typename Point::Component const length = myupper[i] - mylower[i] + 1;
                myPoint[i+1] += shift / length;
                myPoint[i] = mylower[i] + (shift % length);
              }
          }
        else if (n < 0)
          {
            myPoint[0] += n;
            for ( Dimension i = 0; myPoint[i] < mylower[i] && i < Point::dimension - 1; ++i )
              {
                typename Point::Component const shift = myupper[i] - myPoint[i];
                typename Point::Component const length = myupper[i] - mylower[i] + 1;
                myPoint[i+1] -= shift / length;
                myPoint[i] = myupper[i] - (shift % length);
              }
          }
      }
    void advance( DifferenceType const& n ) {…}

    DifferenceType distance_to( const Self& other ) const
      {
        ASSERT_MSG( // we should only compare iterators on the same domain
            mylower == other.mylower && myupper == other.myupper,
            "The compared iterators iterate on different domains."
        );
 
        return other.pos - pos;
      }
    DifferenceType distance_to( const Self& other ) const {…}
 
  private:
    TPoint myPoint;

    TPoint mylower, myupper;

    DifferenceType pos;
 
  }; // End of class HyperRectDomain_Iterator
  class HyperRectDomain_Iterator {…};

  // class HyperRectDomain_subIterator
  template<typename TPoint>
  class HyperRectDomain_subIterator
    : public boost::iterator_facade <
        HyperRectDomain_subIterator<TPoint>,
        const TPoint,
        std::random_access_iterator_tag,
        TPoint const&,
        typename std::conditional<std::is_same<typename TPoint::Component, BigInteger>::value, BigInteger, std::ptrdiff_t>::type
      >
  {
  public:
    using Point = TPoint;
    using Self  = HyperRectDomain_subIterator<TPoint>;
    using Dimension = typename Point::Dimension;
    using DifferenceType = typename std::iterator_traits<Self>::difference_type; 
 
    HyperRectDomain_subIterator(const TPoint & p, const TPoint& lower,
        const TPoint &upper,
        const std::vector<Dimension> &subDomain)
      : myPoint( p ), mylower( lower ), myupper( upper )
      {
        ASSERT_MSG( // For an empty domain, lower = upper + diag(1) so that begin() == end().
            lower.isLower(upper) || lower == upper + TPoint::diagonal(0).partialCopy( TPoint::diagonal(1), subDomain ),
            "The lower bound must be lower than the upper bound or, for an empty domain, be equal to the upper bound + diagonal(1)."
        );
 
        ASSERT_MSG(
            ( lower.isLower(p) && p.isLower(upper) ) || p == lower || p == upper,
            "The point must be inside the domain or be equal to one of his bound."
        );
 
        ASSERT_MSG(
            subDomain.size() <= TPoint::dimension,
            "The sub-range cannot have more dimensions than the ambiant space."
        );
 
        mySubDomain.reserve( subDomain.size() );
        for ( typename std::vector<Dimension>::const_iterator it = subDomain.begin();
            it != subDomain.end(); ++it )
          {
            ASSERT_MSG(
                *it <= TPoint::dimension,
                "Invalid dimension in the sub-range."
            );
            mySubDomain.push_back( *it );
          }
 
        // Calculating iterator position in the sequence
        pos = 0;
        DifferenceType delta = 1;
        for ( Dimension i = 0; i < mySubDomain.size(); ++i )
          {
            auto const ii = mySubDomain[i];
            pos += delta * (myPoint[ii] - mylower[ii]);
            delta *= myupper[ii] - mylower[ii] + 1;
          }
      }
    HyperRectDomain_subIterator(const TPoint & p, const TPoint& lower, {…}
 
  private:
    friend class boost::iterator_core_access;

    const Point& dereference() const
      {
        ASSERT_MSG( // we must be between [begin,end]
            mylower.isLower(myPoint) && myPoint.isLower(myupper),
            "The iterator points outside the domain."
        );
 
        return myPoint;
 
      }
    const Point& dereference() const {…}

    bool equal( const Self &other ) const
      {
        ASSERT_MSG( // we should only compare iterators on the same domain and same dimensions
            mylower == other.mylower && myupper == other.myupper && mySubDomain == other.mySubDomain,
            "The compared iterators iterate on different domains or different dimensions."
        );
 
        return pos == other.pos;
      }
    bool equal( const Self &other ) const {…}
 

    void increment()
      {
        ++pos;
        ++myPoint[mySubDomain[0]];
        for ( Dimension i = 0; myPoint[mySubDomain[i]] > myupper[mySubDomain[i]] && i < mySubDomain.size() - 1; ++i )
          {
            ++myPoint[mySubDomain[i+1]];
            myPoint[mySubDomain[i]] = mylower[mySubDomain[i]];
          }
      }
    void increment() {…}

    void decrement()
      {
        --pos;
        --myPoint[mySubDomain[0]];
        for ( Dimension i = 0; myPoint[mySubDomain[i]] < mylower[mySubDomain[i]] && i < mySubDomain.size() - 1; ++i )
          {
            --myPoint[mySubDomain[i+1]];
            myPoint[mySubDomain[i]] = myupper[mySubDomain[i]];
          }
      }
    void decrement() {…}

    void advance( DifferenceType const& n )
      {
        pos += n;
        if (n > 0)
          {
            myPoint[mySubDomain[0]] += n;
            for ( Dimension i = 0; myPoint[mySubDomain[i]] > myupper[mySubDomain[i]] && i < mySubDomain.size() - 1; ++i )
              {
                auto const ii = mySubDomain[i];
                typename Point::Component const shift = myPoint[ii] - mylower[ii];
                typename Point::Component const length = myupper[ii] - mylower[ii] + 1;
                myPoint[mySubDomain[i+1]] += shift / length;
                myPoint[ii] = mylower[ii] + (shift % length);
              }
          }
        else if (n < 0)
          {
            myPoint[mySubDomain[0]] += n;
            for ( Dimension i = 0; myPoint[mySubDomain[i]] < mylower[mySubDomain[i]] && i < mySubDomain.size() - 1; ++i )
              {
                auto const ii = mySubDomain[i];
                typename Point::Component const shift = myupper[ii] - myPoint[ii];
                typename Point::Component const length = myupper[ii] - mylower[ii] + 1;
                myPoint[mySubDomain[i+1]] -= shift / length;
                myPoint[ii] = myupper[ii] - (shift % length);
              }
          }
      }
    void advance( DifferenceType const& n ) {…}

    DifferenceType distance_to( const Self& other ) const
      {
        ASSERT_MSG( // we should only compare iterators on the same domain and same dimensions
            mylower == other.mylower && myupper == other.myupper && mySubDomain == other.mySubDomain,
            "The compared iterators iterate on different domains or different dimensions."
        );
 
        return other.pos - pos;
      }
    DifferenceType distance_to( const Self& other ) const {…}
 
  private:
    TPoint myPoint;

    TPoint mylower, myupper;

    std::vector<Dimension> mySubDomain;

    DifferenceType pos;
 
  }; // End of class HyperRectDomain_subIterator
  class HyperRectDomain_subIterator {…};
 
} //namespace
//                                                                           //
 
#endif // !defined HyperRectDomain_Iterator_h
 
#undef HyperRectDomain_Iterator_RECURSES
#endif // else defined(HyperRectDomain_Iterator_RECURSES)