#include <MaximalSegments.h>

Public Member Functions
	SegmentIterator (MaximalSegments< Segment > *aCov, const Iterator &aBack, const Segment &aSegment)
	SegmentIterator (const SegmentIterator &aOther)
SegmentIterator &	operator= (const SegmentIterator &aOther)
	~SegmentIterator ()
Segment	operator* () const
Segment	get () const
SegmentIterator &	operator++ ()
bool	intersectNext () const
bool	intersectPrevious () const
const Iterator	getFront () const
const Iterator	getBack () const
bool	operator== (const SegmentIterator &aOther) const
bool	operator!= (const SegmentIterator &aOther) const

Private Member Functions
template<typename TypeSegment , typename TypeIterator >
void	extension (TypeSegment &aSeg, TypeIterator &it, const TypeIterator &end)
template<typename TypeSegment , typename TypeIterator >
void	extension (TypeSegment &aSeg, TypeIterator &it)
template<typename TypeSegment , typename TypeIterator >
void	extensionInLoop (TypeSegment &aSeg, TypeIterator &it, const TypeIterator &begin, const TypeIterator &end)
void	firstMaximalSegment ()
void	nextMaximalSegment ()
bool	doesIntersectNext (const Iterator &it)

Private Attributes
MaximalSegments< Segment > *	myCov
Iterator	myFront
Iterator	myBack
Segment	mySegment
bool	myFlagIntersectNext
bool	myFlagIntersectPrevious
bool	myFlag

Friends
class	MaximalSegments< Segment >

Detailed Description

template<typename TSegment>
class DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator

This class is an iterator on a sequence storing the current segment.

Definition at line 129 of file MaximalSegments.h.

Constructor & Destructor Documentation

template<typename TSegment >

DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::SegmentIterator	(	MaximalSegments< Segment > *	aCov,
		const Iterator &	aBack,
		const Segment &	aSegment
	)

inline

Constructor. Nb: complexity in O(n).

Parameters:

aCov	the set of maximal segments
aBack	an iterator at the back of the first segment

Constructor. Nb: complexity in O(n).

Parameters:

anIterator an iterator on the digital curve to decompose

Definition at line 266 of file MaximalSegments.ih.

References DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::firstMaximalSegment(), DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::myBack, DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::myCov, and DGtal::deprecated::MaximalSegments< TSegment >::myEnd.

  : myCov( aCov ), 
    myFront( aBack ), 
    myBack( aBack ),
    mySegment( aSegment ), 
    myFlagIntersectNext(false),
    myFlagIntersectPrevious(false),
    myFlag(false)
{
  if (myBack != myCov->myEnd) {
    this->firstMaximalSegment();
  }
}

template<typename TSegment >

DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::SegmentIterator ( const SegmentIterator & aOther )

inline

Copy constructor.

Parameters:

other the iterator to clone.

Definition at line 290 of file MaximalSegments.ih.

  : myCov( aOther.myCov ), 
    myFront( aOther.myFront ), myBack( aOther.myBack ),
    mySegment( aOther.mySegment ), 
    myFlagIntersectNext( aOther.myFlagIntersectNext ), 
    myFlagIntersectPrevious( aOther.myFlagIntersectPrevious ),
    myFlag( aOther.myFlag )
{
}

template<typename TSegment >

DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::~SegmentIterator ( )

inline

Destructor. Does nothing.

Destructor. Does nothing

Definition at line 330 of file MaximalSegments.ih.

{

}

Member Function Documentation

template<typename TSegment >

bool DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::doesIntersectNext ( const Iterator & it )

inlineprivate

Checks if the current segment intersects the next one (if exists).

Parameters:

it	a given iterator

Checks if the current segment intersects the next one (if exists).

Definition at line 49 of file MaximalSegments.ih.

{
    Segment tmpSegment;
    Iterator previousIt = it; --previousIt;
    tmpSegment.init(previousIt);
    return tmpSegment.extendForward(it);
}

template<typename TSegment >

template<typename TypeSegment , typename TypeIterator >

void DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::extension	(	TypeSegment &	aSeg,
		TypeIterator &	it,
		const TypeIterator &	end
	)

inlineprivate

Extension of the segment along the sequence while it is possible.

Parameters:

aSeg	a segment computer
it	an iterator on a sequence
end	an iterator after the end of the sequence Nb: complexity in O(n).

Extension of the segment along the sequence while it is possible. Nb: complexity in O(n).

Definition at line 205 of file MaximalSegments.ih.

                                                                               {
    do {
      ++it;
    } while ( (it != end) && 
            (aSeg.extendForward(it)) );
}

template<typename TSegment >

template<typename TypeSegment , typename TypeIterator >

void DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::extension	(	TypeSegment &	aSeg,
		TypeIterator &	it
	)

inlineprivate

Extension of the segment along the sequence while it is possible.

Parameters:

aSeg	a segment computer
it	an iterator on a sequence Nb: complexity in O(n).

Extension of the segment along the sequence while it is possible. Nb: complexity in O(n).

Definition at line 222 of file MaximalSegments.ih.

{
  do {
    ++it;
  } while (aSeg.extendForward(it));
}

template<typename TSegment >

template<typename TypeSegment , typename TypeIterator >

void DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::extensionInLoop	(	TypeSegment &	aSeg,
		TypeIterator &	it,
		const TypeIterator &	begin,
		const TypeIterator &	end
	)

inlineprivate

Extension of the segment along the (circular) sequence while it is possible.

Parameters:

aSeg	a segment computer
it	an iterator on a sequence
begin	an iterator at the beginning of the sequence
end	an iterator after the end of the sequence Nb: complexity in O(n).

Extension of the segment along the (circular) sequence while it is possible. Nb: complexity in O(n).

Definition at line 239 of file MaximalSegments.ih.

References DGtal::deprecated::MaximalSegments< TSegment >::begin().

                                                                     {
   do {
     ++it;
   } while ( (it != end) && 
             (aSeg.extendForward(it)) );
    //if it is one-element-past-the end, 
    //go on at the beginning
   if (it == end) {
      it = begin;
      while ( (it != end) && 
              (aSeg.extendForward(it)) ) {
        ++it;
      }     
    }
}

template<typename TSegment >

void DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::firstMaximalSegment ( )

inlineprivate

Retrieves the first maximal segment found on the sequence. Nb: complexity in O(n).

Retrieves the first maximal segment of the sequence.

Definition at line 63 of file MaximalSegments.ih.

References DGtal::deprecated::MaximalSegments< TSegment >::mySegment, and DGtal::nextMaximalSegment().

Referenced by DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::SegmentIterator().

{
  mySegment.init(myBack);
  extension<Segment,Iterator>(mySegment,myFront,myCov->myEnd);
  if (myFront != myCov->myEnd) {
    
    if (myCov->isClosed) { //if processed as closed 
      myFlagIntersectNext = doesIntersectNext(myFront);
      nextMaximalSegment();
      myCov->myFirstMaximalSegmentBack = myBack;
    } else {               //if processed as open
      myFlagIntersectNext = doesIntersectNext(myFront);
    }
  }
}

template<typename TSegment >

TSegment DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::get ( ) const

inline

Returns:: the current segment.

Definition at line 355 of file MaximalSegments.ih.

References DGtal::deprecated::MaximalSegments< TSegment >::mySegment.

{
  return mySegment;
}

template<typename TSegment >

const TSegment::ConstIterator DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::getBack ( ) const

inline

Returns:: an iterator of a sequence at the back of the segment.; an iterator of the digital curve at the back of the segment.

Definition at line 395 of file MaximalSegments.ih.

{
  return myBack;
}

template<typename TSegment >

const TSegment::ConstIterator DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::getFront ( ) const

inline

Returns:: an iterator of a sequence at the front of the segment.; an iterator of the digital curve at the front of the segment.

Definition at line 383 of file MaximalSegments.ih.

{
  return myFront;
}

template<typename TSegment >

bool DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::intersectNext ( ) const

inline

Returns:: TRUE if the current segment intersects the next one, FALSE otherwise.

Definition at line 408 of file MaximalSegments.ih.

{
  return myFlagIntersectNext;
}

template<typename TSegment >

bool DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::intersectPrevious ( ) const

inline

Returns:: TRUE if the current segment intersects the previous one, FALSE otherwise.

Definition at line 420 of file MaximalSegments.ih.

{
  return myFlagIntersectPrevious;
}

template<typename TSegment >

void DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::nextMaximalSegment ( )

inlineprivate

Goes to the next maximal segment on the sequence (if possible). Nb: complexity in O(n).

Goes to the next maximal segment on the sequence.

Definition at line 93 of file MaximalSegments.ih.

References DGtal::deprecated::MaximalSegments< TSegment >::mySegment.

{
  myFlagIntersectPrevious = myFlagIntersectNext;
  if (myFlag == false) {
    //if the current segment lies between 
    //the first and last elements 
    //of the sequence
    if (myFront != myCov->myEnd) { //if not the end
      //backward extension
      myBack = myFront;
      ++myBack;
      ReverseIterator ri(myBack);
      ReverseSegment rseg; rseg.init(ri);
      extension<ReverseSegment,ReverseIterator>(rseg,ri);
      myBack = ri.base();
      //forward extension
      myFront = myBack;
      mySegment.init(myFront);
      extension<Segment,Iterator>(mySegment,myFront,myCov->myEnd);
      if (myFront == myCov->myEnd) {
        if (myCov->isClosed) { //if processed as closed 
          //while my segment can be extended at the beginning
          myFront = myCov->myBegin;
          while (mySegment.extendForward(myFront)) {
            ++myFront;
          }
          //overlap
          if (myFront == myCov->myBegin) { 
            Iterator tmpIt = myCov->myEnd; --tmpIt;
            Segment tmpSegment; tmpSegment.init(tmpIt);
            myFlagIntersectNext = tmpSegment.extendForward(myFront);
          } else {
            myFlagIntersectNext = doesIntersectNext(myFront);
          }
          myFlag = true;
        } else {              //if processed as open
          //the current segment is the last one and 
          //does not have any next segment
          myFlagIntersectNext = false;
        }
      } else {
        myFlagIntersectNext = doesIntersectNext(myFront);
      }
    } else { //if the front of the segment is at the end
            // of the sequence
      myBack = myCov->myEnd;
    }
  
  } else {
    //if the current segment contains
    //the first and last element 
    //of the sequence
    //backward extension
    myBack = myFront;
    ++myBack;
    ReverseIterator ri(myBack);
    ReverseSegment rseg; rseg.init(ri);
    extensionInLoop<ReverseSegment,ReverseIterator>( 
                    rseg,ri,
                    ReverseIterator(myCov->myEnd),ReverseIterator(myCov->myBegin) );
    myBack = ri.base();
    if (myBack == myCov->myEnd) myBack = myCov->myBegin;
    if (myBack != myCov->myFirstMaximalSegmentBack) { //if not the end
      //forward extension
      myFront = myBack;
      mySegment.init(myFront);
      extensionInLoop<Segment,Iterator>(mySegment,myFront,myCov->myBegin,myCov->myEnd);
      //overlap
      if (myFront == myCov->myBegin) { 
        Iterator tmpIt = myCov->myEnd; --tmpIt;
        Segment tmpSegment; tmpSegment.init(tmpIt);
        myFlagIntersectNext = tmpSegment.extendForward(myFront);
      } else {
        myFlagIntersectNext = doesIntersectNext(myFront);
      }
    } else { //if the back of the segment is at the 
             //back of the first maximal segment 
      myFront = myCov->myEnd;
      myBack = myCov->myEnd;
    }
  }
}

template<typename TSegment >

bool DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::operator!= ( const SegmentIterator & aOther ) const

inline

Inequality operator.

Parameters:

aOther the iterator to compare with

Returns:: 'true' if their current positions differs. (different front and back iterators)

Inequality operator.

Parameters:

aOther the iterator to compare with

Returns:: 'true' if their current positions differs.

Definition at line 452 of file MaximalSegments.ih.

{
  return ( (myFront != aOther.myFront)||(myBack != aOther.myBack) );
}

template<typename TSegment >

TSegment DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::operator* ( ) const

inline

Returns:: the current segment; the current segment.

Definition at line 344 of file MaximalSegments.ih.

References DGtal::deprecated::MaximalSegments< TSegment >::mySegment.

{
  return mySegment;
}

template<typename TSegment >

DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::SegmentIterator & DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::operator++ ( )

inline

Pre-increment. Goes to the next maximal segment on the sequence (if possible). Nb: complexity in O(n).

Pre-increment. Goes to the next segment on a digital curve.

Definition at line 368 of file MaximalSegments.ih.

References DGtal::nextMaximalSegment().

{
  this->nextMaximalSegment();
  return *this;
}

template<typename TSegment >

DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator & DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::operator= ( const SegmentIterator & other )

inline

Assignment.

Parameters:

aOther the iterator to copy.

Returns:: a reference on 'this'.

Assignment.

Parameters:

other the iterator to copy.

Returns:: a reference on 'this'.

Definition at line 309 of file MaximalSegments.ih.

References DGtal::deprecated::MaximalSegments< TSegment >::mySegment.

{
  if ( this != &other )
    {
      myCov = other.myCov;
      myFront = other.myFront;
      myBack = other.myBack;
      mySegment = other.mySegment;
      myFlagIntersectNext = other.myFlagIntersectNext;
      myFlagIntersectPrevious = other.myFlagIntersectPrevious;
      myFlag = other.myFlag;
    }
  return *this;
}

template<typename TSegment >

bool DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::operator== ( const SegmentIterator & aOther ) const

inline

Equality operator.

Parameters:

aOther the iterator to compare with

Returns:: 'true' if their current positions coincide. (same front and back iterators)

Equality operator.

Parameters:

aOther the iterator to compare with

Returns:: 'true' if their current positions coincide.

Definition at line 436 of file MaximalSegments.ih.

{
  return ( (myFront == aOther.myFront)&&(myBack == aOther.myBack) );
}

Friends And Related Function Documentation

template<typename TSegment>

friend class MaximalSegments< Segment >

friend

Definition at line 184 of file MaximalSegments.h.

Field Documentation

template<typename TSegment>

Iterator DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::myBack

private

An iterator of the sequence at the back of the current segment

Definition at line 151 of file MaximalSegments.h.

Referenced by DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::SegmentIterator().

template<typename TSegment>

MaximalSegments<Segment>* DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::myCov

private

Pointer to the cover of maximal segments

Definition at line 139 of file MaximalSegments.h.

Referenced by DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::SegmentIterator().

template<typename TSegment>

bool DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::myFlag

private

A flag equal to FALSE if the current segment lies between the begin and the end iterator of the sequence, TRUE otherwise. Nb: always FALSE if the sequence is processed as open.

Definition at line 180 of file MaximalSegments.h.

template<typename TSegment>

bool DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::myFlagIntersectNext

private

A flag equal to TRUE if the current segment intersects the next one, FALSE otherwise (and FALSE if the current segment is the last one)

Definition at line 164 of file MaximalSegments.h.

template<typename TSegment>

bool DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::myFlagIntersectPrevious

private

A flag equal to TRUE if the current segment intersects the previous one, FALSE otherwise (and FALSE if the current segment is the first one)

Definition at line 171 of file MaximalSegments.h.

template<typename TSegment>

Iterator DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::myFront

private

An iterator of the sequence at the front of the current segment

Definition at line 145 of file MaximalSegments.h.

template<typename TSegment>

Segment DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator::mySegment

private

The current segment

Definition at line 156 of file MaximalSegments.h.

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

template<typename TSegment> class DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation

template<typename TSegment>
class DGtal::deprecated::MaximalSegments< TSegment >::SegmentIterator