MaximalSegments.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.


// class MaximalSegments<TSegment>::SegmentIterator

  template <typename TSegment>
inline
bool
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::doesIntersectNext(const Iterator& it)
{
    Segment tmpSegment;
    Iterator previousIt = it; --previousIt;
    tmpSegment.init(previousIt);
    return tmpSegment.extendForward(it);
}

template <typename TSegment>
inline
void
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::firstMaximalSegment()
{

  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>
inline
void
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::nextMaximalSegment()
{

  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>
template <typename TypeSegment, typename TypeIterator>
inline
void
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::
       extension(TypeSegment& aSeg, TypeIterator& it, const TypeIterator& end) {
    do {
      ++it;
    } while ( (it != end) && 
            (aSeg.extendForward(it)) );
}



template <typename TSegment>
template <typename TypeSegment, typename TypeIterator>
inline
void
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::extension(TypeSegment& aSeg, TypeIterator& it) 
{
  do {
    ++it;
  } while (aSeg.extendForward(it));
}


 template <typename TSegment>
template <typename TypeSegment, typename TypeIterator>
inline
 void
 DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::
 extensionInLoop(TypeSegment& aSeg, TypeIterator& it, 
                 const TypeIterator& begin, const TypeIterator& end) {
   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;
      }     
    }
}
// ------------------------- Standard services -----------------------

template <typename TSegment>
inline
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::SegmentIterator(MaximalSegments<Segment> *aCov,
                                                                               const Iterator& aBack,
                                                                               const Segment& aSegment )
  : myCov( aCov ), 
    myFront( aBack ), 
    myBack( aBack ),
    mySegment( aSegment ), 
    myFlagIntersectNext(false),
    myFlagIntersectPrevious(false),
    myFlag(false)
{
  if (myBack != myCov->myEnd) {
    this->firstMaximalSegment();
  }
}


template <typename TSegment>
inline
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator
::SegmentIterator( const SegmentIterator & aOther )
  : myCov( aOther.myCov ), 
    myFront( aOther.myFront ), myBack( aOther.myBack ),
    mySegment( aOther.mySegment ), 
    myFlagIntersectNext( aOther.myFlagIntersectNext ), 
    myFlagIntersectPrevious( aOther.myFlagIntersectPrevious ),
    myFlag( aOther.myFlag )
{
}
    
template <typename TSegment>
inline
typename DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator& 
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::operator=
( const SegmentIterator & other )
{
  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>
inline
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::~SegmentIterator()
{
}

// ------------------------- iteration services -------------------------
    
      
  template <typename TSegment>
inline
TSegment
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::operator*() const
{
  return mySegment;
}

  template <typename TSegment>
inline
TSegment
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::get() const
{
  return mySegment;
}

  template <typename TSegment>
inline
typename DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::SegmentIterator& 
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::operator++()
{
  this->nextMaximalSegment();
  return *this;
}



  template <typename TSegment>
inline
const typename TSegment::ConstIterator
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::getFront() const
{
  return myFront;
}

  template <typename TSegment>
inline
const typename TSegment::ConstIterator
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::getBack() const
{
  return myBack;
}


  template <typename TSegment>
inline
bool
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::intersectNext() const
{
  return myFlagIntersectNext;
}

  template <typename TSegment>
inline
bool
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::intersectPrevious() const
{
  return myFlagIntersectPrevious;
}

  template <typename TSegment>
inline
bool
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::operator==
( const SegmentIterator & aOther ) const
{
  return ( (myFront == aOther.myFront)&&(myBack == aOther.myBack) );
}

  template <typename TSegment>
inline
bool
DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator::operator!=
( const SegmentIterator & aOther ) const
{
  return ( (myFront != aOther.myFront)||(myBack != aOther.myBack) );
}


// class MaximalSegments<TSegment>

// Interface - public :

  template <typename TSegment>
DGtal::deprecated::MaximalSegments<TSegment>::MaximalSegments(
  const Iterator& aBegin, 
  const Iterator& aEnd, 
  const Segment& aSegment, 
  const bool& aFlag)
  : myBegin(aBegin),
    myEnd(aEnd),
    myFirstMaximalSegmentBack(aBegin),
    mySegment(aSegment),
    isClosed(aFlag)
{
}

  template <typename TSegment>
inline
void
DGtal::deprecated::MaximalSegments<TSegment>::init(
  const Iterator& aBegin, 
  const Iterator& aEnd, 
  const Segment& aSegment, 
  const bool& aFlag) {

 myBegin = aBegin;
 myEnd = aEnd;
 myFirstMaximalSegmentBack = aBegin;
 mySegment = aSegment;
 isClosed = aFlag;

}

  template <typename TSegment>
inline
DGtal::deprecated::MaximalSegments<TSegment>::~MaximalSegments()
{
}

  template <typename TSegment>
inline
typename DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator 
DGtal::deprecated::MaximalSegments<TSegment>::begin() 
{
  return SegmentIterator(this, myBegin, mySegment);
}

  template <typename TSegment>
inline
typename DGtal::deprecated::MaximalSegments<TSegment>::SegmentIterator 
DGtal::deprecated::MaximalSegments<TSegment>::end() 
{
  return SegmentIterator(this, myEnd, mySegment);
}


  template <typename TSegment>
inline
void
DGtal::deprecated::MaximalSegments<TSegment>::selfDisplay ( std::ostream & out ) const
{
  out << "[MaximalSegments]";
}

  template <typename TSegment>
inline
bool
DGtal::deprecated::MaximalSegments<TSegment>::isValid() const
{
    return true;
}



// Implementation of inline functions                                        //

  template <typename TSegment>
inline
std::ostream&
DGtal::deprecated::operator<< ( std::ostream & out, 
      const MaximalSegments<TSegment> & object )
{
  object.selfDisplay( out );
  return out;
}

//                                                                           //