#include <DGtal/kernel/domains/HyperRectDomain_Iterator.h>

Inheritance diagram for DGtal::HyperRectDomain_Iterator< TPoint >:

Public Types
using	Point = TPoint

using	Self = HyperRectDomain_Iterator< TPoint >

using	Dimension = typename Point::Dimension

using	DifferenceType = typename std::iterator_traits< Self >::difference_type
	Type of the difference between two iterators (usually std::ptrdiff_t except for BigInteger). More...

Public Member Functions
	HyperRectDomain_Iterator (const Point &p, const Point &lower, const Point &upper)
	HyperRectDomain iterator constructor. More...

Private Member Functions
const Point &	dereference () const
	Dereference. More...

bool	equal (const Self &other) const
	Compare iterators. More...

void	increment ()
	Increments the iterator in order to scan the domain points dimension by dimension (lexicographic order). More...

void	decrement ()
	Decrements the iterator in order to scan the domain points dimension by dimension (lexicographic order). More...

void	advance (DifferenceType const &n)
	Advances the iterator in order to scan the domain points dimension by dimension (lexicographic order). More...

DifferenceType	distance_to (const Self &other) const
	Distance between two iterators on the same domain (lexicographic order). More...

Private Attributes
TPoint	myPoint
	Current Point in the domain. More...

TPoint	mylower
	Copies of the Domain limits. More...

TPoint	myupper

DifferenceType	pos
	Iterator position in the current sequence. More...

Friends
class	boost::iterator_core_access

Detailed Description

template<typename TPoint>
class DGtal::HyperRectDomain_Iterator< TPoint >

Iterator for HyperRectDomain.

Template Parameters

TPoint Point type.

Definition at line 142 of file HyperRectDomain_Iterator.h.

Member Typedef Documentation

◆ DifferenceType

template<typename TPoint >

using DGtal::HyperRectDomain_Iterator< TPoint >::DifferenceType = typename std::iterator_traits<Self>::difference_type

Type of the difference between two iterators (usually std::ptrdiff_t except for BigInteger).

Definition at line 159 of file HyperRectDomain_Iterator.h.

◆ Dimension

template<typename TPoint >

using DGtal::HyperRectDomain_Iterator< TPoint >::Dimension = typename Point::Dimension

Definition at line 158 of file HyperRectDomain_Iterator.h.

◆ Point

template<typename TPoint >

using DGtal::HyperRectDomain_Iterator< TPoint >::Point = TPoint

Definition at line 156 of file HyperRectDomain_Iterator.h.

◆ Self

template<typename TPoint >

using DGtal::HyperRectDomain_Iterator< TPoint >::Self = HyperRectDomain_Iterator<TPoint>

Definition at line 157 of file HyperRectDomain_Iterator.h.

Constructor & Destructor Documentation

◆ HyperRectDomain_Iterator()

template<typename TPoint >

DGtal::HyperRectDomain_Iterator< TPoint >::HyperRectDomain_Iterator	(	const Point &	p,
		const Point &	lower,
		const Point &	upper
	)

inline

HyperRectDomain iterator constructor.

Parameters

p	The point pointed by this iterator
lower	Lower bound of the iterated domain
upper	Upper bound of the iterated domain

Precondition: p must lie inside the given bounds or be equal to one of its bound; the bounds must describe a valid (possibly empty) domain

Definition at line 171 of file HyperRectDomain_Iterator.h.

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

References lower(), DGtal::HyperRectDomain_Iterator< TPoint >::mylower, DGtal::HyperRectDomain_Iterator< TPoint >::myPoint, DGtal::HyperRectDomain_Iterator< TPoint >::myupper, DGtal::HyperRectDomain_Iterator< TPoint >::pos, and upper().

Member Function Documentation

◆ advance()

template<typename TPoint >

void DGtal::HyperRectDomain_Iterator< TPoint >::advance ( DifferenceType const & n )

inlineprivate

Advances the iterator in order to scan the domain points dimension by dimension (lexicographic order).

Definition at line 257 of file HyperRectDomain_Iterator.h.

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

References DGtal::HyperRectDomain_Iterator< TPoint >::mylower, DGtal::HyperRectDomain_Iterator< TPoint >::myPoint, DGtal::HyperRectDomain_Iterator< TPoint >::myupper, and DGtal::HyperRectDomain_Iterator< TPoint >::pos.

◆ decrement()

template<typename TPoint >

void DGtal::HyperRectDomain_Iterator< TPoint >::decrement ( )

inlineprivate

Decrements the iterator in order to scan the domain points dimension by dimension (lexicographic order).

Definition at line 242 of file HyperRectDomain_Iterator.h.

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

References DGtal::HyperRectDomain_Iterator< TPoint >::mylower, DGtal::HyperRectDomain_Iterator< TPoint >::myPoint, DGtal::HyperRectDomain_Iterator< TPoint >::myupper, and DGtal::HyperRectDomain_Iterator< TPoint >::pos.

◆ dereference()

template<typename TPoint >

const Point& DGtal::HyperRectDomain_Iterator< TPoint >::dereference ( ) const

inlineprivate

Dereference.

Definition at line 198 of file HyperRectDomain_Iterator.h.

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

References DGtal::HyperRectDomain_Iterator< TPoint >::mylower, DGtal::HyperRectDomain_Iterator< TPoint >::myPoint, and DGtal::HyperRectDomain_Iterator< TPoint >::myupper.

◆ distance_to()

template<typename TPoint >

DifferenceType DGtal::HyperRectDomain_Iterator< TPoint >::distance_to ( const Self & other ) const

inlineprivate

Distance between two iterators on the same domain (lexicographic order).

Definition at line 287 of file HyperRectDomain_Iterator.h.

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

References DGtal::HyperRectDomain_Iterator< TPoint >::mylower, DGtal::HyperRectDomain_Iterator< TPoint >::myupper, and DGtal::HyperRectDomain_Iterator< TPoint >::pos.

◆ equal()

template<typename TPoint >

bool DGtal::HyperRectDomain_Iterator< TPoint >::equal ( const Self & other ) const

inlineprivate

Compare iterators.

Note: compare only the pointed point, not the iterated domain.

Definition at line 213 of file HyperRectDomain_Iterator.h.

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

References DGtal::HyperRectDomain_Iterator< TPoint >::mylower, DGtal::HyperRectDomain_Iterator< TPoint >::myupper, and DGtal::HyperRectDomain_Iterator< TPoint >::pos.

◆ increment()

template<typename TPoint >

void DGtal::HyperRectDomain_Iterator< TPoint >::increment ( )

inlineprivate

Increments the iterator in order to scan the domain points dimension by dimension (lexicographic order).

Definition at line 227 of file HyperRectDomain_Iterator.h.

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