DGtal: DGtal::HyperRectDomain_subIterator< TPoint

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

Inheritance diagram for DGtal::HyperRectDomain_subIterator< TPoint >:

Public Types
using	Point = TPoint

using	Self = HyperRectDomain_subIterator< 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_subIterator (const TPoint &p, const TPoint &lower, const TPoint &upper, const std::vector< Dimension > &subDomain)

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 (by using the subDomain order given by the user). More...

void	decrement ()
	Decrements the iterator in order to scan the domain points dimension by dimension (by using the subDomain order given by the user). More...

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

DifferenceType	distance_to (const Self &other) const
	Distance between two iterators on the same domain (by using the subDomain order given by the user). More...

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

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

TPoint	myupper

std::vector< Dimension >	mySubDomain

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

Friends
class	boost::iterator_core_access

Detailed Description

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

Description of class 'HyperRectDomain_subIterator'

Aim:

Definition at line 316 of file HyperRectDomain_Iterator.h.

Member Typedef Documentation

◆ DifferenceType

template<typename TPoint >

using DGtal::HyperRectDomain_subIterator< 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 333 of file HyperRectDomain_Iterator.h.

◆ Dimension

template<typename TPoint >

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

Definition at line 332 of file HyperRectDomain_Iterator.h.

◆ Point

template<typename TPoint >

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

Definition at line 330 of file HyperRectDomain_Iterator.h.

◆ Self

template<typename TPoint >

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

Definition at line 331 of file HyperRectDomain_Iterator.h.

Constructor & Destructor Documentation

◆ HyperRectDomain_subIterator()

template<typename TPoint >

DGtal::HyperRectDomain_subIterator< TPoint >::HyperRectDomain_subIterator	(	const TPoint &	p,
		const TPoint &	lower,
		const TPoint &	upper,
		const std::vector< Dimension > &	subDomain
	)

inline

Definition at line 335 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(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;
           }
       }

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

Member Function Documentation

◆ advance()

template<typename TPoint >

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

inlineprivate

Advances the iterator in order to scan the domain points dimension by dimension (by using the subDomain order given by the user).

Definition at line 441 of file HyperRectDomain_Iterator.h.

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

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

◆ decrement()

template<typename TPoint >

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

inlineprivate

Decrements the iterator in order to scan the domain points dimension by dimension (by using the subDomain order given by the user).

Definition at line 426 of file HyperRectDomain_Iterator.h.

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

◆ dereference()

template<typename TPoint >

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

inlineprivate

Dereference.

Definition at line 381 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_subIterator< TPoint >::mylower, DGtal::HyperRectDomain_subIterator< TPoint >::myPoint, and DGtal::HyperRectDomain_subIterator< TPoint >::myupper.

◆ distance_to()

template<typename TPoint >

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

inlineprivate

Distance between two iterators on the same domain (by using the subDomain order given by the user).

Definition at line 474 of file HyperRectDomain_Iterator.h.

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

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

◆ equal()

template<typename TPoint >

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

inlineprivate

Compare iterators.

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

Definition at line 396 of file HyperRectDomain_Iterator.h.

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

◆ increment()

template<typename TPoint >

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

inlineprivate

Increments the iterator in order to scan the domain points dimension by dimension (by using the subDomain order given by the user).

Definition at line 411 of file HyperRectDomain_Iterator.h.

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