GreedyDecomposition.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.

// class GreedyDecomposition::SegmentIterator

// ------------------------- Standard services -----------------------



 template <typename TSegment>
inline
DGtal::deprecated::GreedyDecomposition<TSegment>::SegmentIterator::SegmentIterator ( 
  const GreedyDecomposition<TSegment> *aDec,
  const typename TSegment::ConstIterator& aBack, 
  const TSegment& aSegment)
  : myDec( aDec ), 
    myFront( aBack ), 
    myBack( aBack ),
    mySegment( aSegment ), 
    myFlagIntersectNext(false),
    myFlagIntersectPrevious(false)
{
  if (myBack != myDec->myEnd) {   //if at least one element

    ++myFront;
    if (myFront == myDec->myEnd) {//if only one element
      
      mySegment.init(myBack);  

    } else {                      //if strictly more than one element

      if (myDec->isClosed) { //if processed as closed
        //check is the first and last element form a valid segment
        Iterator tmpIt = myDec->myEnd; --tmpIt;
        Segment tmpSegment; tmpSegment.init(tmpIt);
        myFlagIntersectPrevious = tmpSegment.extendForward(myDec->myBegin);
      } else {              //if processed as open
        myFlagIntersectPrevious = false;
      }
      //computation of the longest segment from myBack
      this->longestSegment();  
  
    }

  }
}



  template <typename TSegment>
inline
DGtal::deprecated::GreedyDecomposition<TSegment>::SegmentIterator::SegmentIterator
( const SegmentIterator & aOther )
  : myDec( aOther.myDec ), 
    myFront( aOther.myFront ), 
    myBack( aOther.myBack ),
    mySegment( aOther.mySegment ),
    myFlagIntersectNext( aOther.myFlagIntersectNext ), 
    myFlagIntersectPrevious( aOther.myFlagIntersectPrevious )  
{
}
    
  template <typename TSegment>
inline
typename DGtal::deprecated::GreedyDecomposition<TSegment>::SegmentIterator& 
DGtal::deprecated::GreedyDecomposition<TSegment>::SegmentIterator::operator=
( const SegmentIterator & other )
{
  if ( this != &other )
    {
      myDec = other.myDec;
      myFront = other.myFront;
      myBack = other.myBack;
      mySegment = other.mySegment;
      myFlagIntersectNext = other.myFlagIntersectNext;
      myFlagIntersectPrevious = other.myFlagIntersectPrevious;
    }
  return *this;
}
    
  template <typename TSegment>
inline
DGtal::deprecated::GreedyDecomposition<TSegment>::SegmentIterator::~SegmentIterator()
{
}

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

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

  template <typename TSegment>
inline
typename DGtal::deprecated::GreedyDecomposition<TSegment>::SegmentIterator & 
DGtal::deprecated::GreedyDecomposition<TSegment>::SegmentIterator::operator++()
{
  this->next();
  return *this;
}
    
  template <typename TSegment>
inline
bool
DGtal::deprecated::GreedyDecomposition<TSegment>::SegmentIterator::intersectNext() const
{
  return myFlagIntersectNext;
}

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

  template <typename TSegment>
inline
bool
DGtal::deprecated::GreedyDecomposition<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::GreedyDecomposition<TSegment>::SegmentIterator::longestSegment()
{

    mySegment.init(myBack);

    //while my segment can be extended at the front
    while ( (myFront != myDec->myEnd) && 
            (mySegment.extendForward(myFront)) ) {
      ++myFront;
    }

    //if the end of the sequence is reached
    if (myFront == myDec->myEnd) {
      //if the sequence is processed as a closed one
      //the first element of the sequence is added if possible
      if (myDec->isClosed) {
        myFlagIntersectNext = mySegment.extendForward(myDec->myBegin);
      } else {
        myFlagIntersectNext = false;
      } 
    } else {
    //otherwise
      myFlagIntersectNext = doesIntersectNext(myFront);
    }

}

  
  template <typename TSegment>
inline
void
DGtal::deprecated::GreedyDecomposition<TSegment>::SegmentIterator::next()
{

  if (myFront != myDec->myEnd) { //if not the end

    myBack = myFront;

    myFlagIntersectPrevious = myFlagIntersectNext;

    if (myFlagIntersectPrevious) {
      --myBack; 
    } else {
      ++myFront;
    }

    this->longestSegment();

  } else { //if the front of the segment is at the end of the sequence
    myBack = myDec->myEnd;
  }
}


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

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


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

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


// class GreedyDecomposition

// Interface - public :


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

  template <typename TSegment>
inline
void
DGtal::deprecated::GreedyDecomposition<TSegment>::init
(const Iterator& aBegin, const Iterator& aEnd, const Segment& aSegment, const bool& aFlag)
{
  myBegin = aBegin;
  myEnd = aEnd;
  mySegment = aSegment;
  isClosed = aFlag;
}

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

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

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


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

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



// Implementation of inline functions                                        //

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

//                                                                           //