GreedySegmentation.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.

// class GreedySegmentation::SegmentComputerIterator

// ------------------------- Main processings -----------------------


  template <typename TSegmentComputer>
inline
bool
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::doesIntersectNext(const ConstIterator& it, const ConstIterator& itb, const ConstIterator& ite)
{
  typedef typename IteratorCirculatorTraits<typename SegmentComputer::ConstIterator>::Type Type; 
  return this->doesIntersectNext( it, itb, ite, Type() );
}

  template <typename TSegmentComputer>
inline
bool
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::doesIntersectNext(const ConstIterator& it, const ConstIterator& itb, const ConstIterator& ite, IteratorType )
{
    ConstIterator previousIt(it); 
    if ( (it != itb)&&(it != ite) ) 
      {
        --previousIt;
        SegmentComputer tmpSegmentComputer=mySegmentComputer.getSelf();
        tmpSegmentComputer.init(previousIt);
        return tmpSegmentComputer.extendForward();
      } 
    else 
      {
        return false; 
      }
}


  template <typename TSegmentComputer>
inline
bool
  DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::doesIntersectNext(const ConstIterator& it, const ConstIterator& /*itb*/, const ConstIterator& /*ite*/, CirculatorType )
{
  return this->doesIntersectNext(it);
}


  template <typename TSegmentComputer>
inline
bool
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::doesIntersectNext(const ConstIterator& it)
{
  ConstIterator previousIt(it); --previousIt;
  
  SegmentComputer tmpSegmentComputer=mySegmentComputer.getSelf();
  tmpSegmentComputer.init(previousIt);
  return tmpSegmentComputer.extendForward();
}


template <typename TSegmentComputer>
inline
void
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::longestSegment(const ConstIterator& it)
{

  mySegmentComputer.init(it);

  //while my segmentComputer can be extended
  while ( (mySegmentComputer.end() != myS->myStop)
    &&(mySegmentComputer.extendForward()) ) {} 

  //if the end is reached
  if (mySegmentComputer.end() == myS->myStop) {

    myFlagIntersectNext = doesIntersectNext( mySegmentComputer.end(), myS->myBegin, myS->myEnd );
    myFlagIsLast = true; 

    //last extension
    if ( isNotEmpty<ConstIterator>(myS->myStop, myS->myEnd) ) { 
      if (myS->myMode == "Truncate+1") {
        mySegmentComputer.extendForward(); 
      }
      if (myS->myMode == "DoNotTruncate") {
        while ( (mySegmentComputer.extendForward())
             && (mySegmentComputer.end() != myS->myEnd) ) {} 
      }
    }

  } else {
  //otherwise
    myFlagIntersectNext = doesIntersectNext( mySegmentComputer.end() );
  }
}


  template <typename TSegmentComputer>
inline
void
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::next()
{

  if (myFlagIsLast) { //if the segmentComputer has reached the end

    myFlagIsValid = false; 

  } else { //otherwise

    myFlagIntersectPrevious = myFlagIntersectNext;

    ConstIterator it( mySegmentComputer.end() ); 
    if (myFlagIntersectPrevious) --it; 

    this->longestSegment(it);

  }

}

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


 template <typename TSegmentComputer>
inline
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::SegmentComputerIterator ( 
  const GreedySegmentation<TSegmentComputer> *s,
  const TSegmentComputer& aSegmentComputer,
  const bool& aIsValid )
  : myS( s ), 
    mySegmentComputer( aSegmentComputer ), 
    myFlagIsValid( aIsValid ),
    myFlagIntersectNext( false ),
    myFlagIntersectPrevious( false ),
    myFlagIsLast( false )
{
 
 if (myFlagIsValid)
   {
     if ( isNotEmpty<ConstIterator>(myS->myStart, myS->myStop) ) 
       {   //if at least one element
 
         myFlagIntersectPrevious = doesIntersectNext( myS->myStart, myS->myBegin, myS->myEnd );
         
         //computation of the longest segment from myS->myStart
         this->longestSegment(myS->myStart);  
 
        } 
      else 
       {
         myFlagIsValid = false;
       }
   }
}


  template <typename TSegmentComputer>
inline
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::SegmentComputerIterator
( const SegmentComputerIterator & other )
  : myS( other.myS ), 
    mySegmentComputer( other.mySegmentComputer ),
    myFlagIsValid( other.myFlagIsValid ),
    myFlagIntersectNext( other.myFlagIntersectNext ), 
    myFlagIntersectPrevious( other.myFlagIntersectPrevious ) ,
    myFlagIsLast( other.myFlagIsLast )
{
}


  template <typename TSegmentComputer>
inline
typename DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator& 
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::operator=
( const SegmentComputerIterator & other )
{
  if ( this != &other )
    {
      myS = other.myS;
      mySegmentComputer = other.mySegmentComputer;
      myFlagIsValid = other.myFlagIsValid;
      myFlagIntersectNext = other.myFlagIntersectNext;
      myFlagIntersectPrevious = other.myFlagIntersectPrevious;
      myFlagIsLast = other.myFlagIsLast;
    }
  return *this;
}
    

  template <typename TSegmentComputer>
inline
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::~SegmentComputerIterator()
{
}

// ------------------------- iteration services -------------------------
    

  template <typename TSegmentComputer>
inline
const TSegmentComputer&
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::operator*() const
{
  return mySegmentComputer;
}

  template <typename TSegmentComputer>
inline
const TSegmentComputer*
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::operator->() const
{
  return &mySegmentComputer;
}


  template <typename TSegmentComputer>
inline
TSegmentComputer
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::get() const
{
  return mySegmentComputer;
}

  template <typename TSegmentComputer>
inline
typename DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator & 
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::operator++()
{
  this->next();
  return *this;
}
    


  template <typename TSegmentComputer>
inline
bool
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::operator==
( const SegmentComputerIterator & other ) const
{

 if ( isValid() ) 
  return ( (other.isValid() ) && 
( mySegmentComputer.begin() == other.mySegmentComputer.begin() ) &&
( mySegmentComputer.end() == other.mySegmentComputer.end() ) );  
 else 
  return ( ! other.isValid() );
}


  template <typename TSegmentComputer>
inline
bool
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::operator!=
( const SegmentComputerIterator & other ) const
{
  return !(*this == other);
}


// ------------------------- accessors -------------------------
  
  template <typename TSegmentComputer>
inline
bool
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::intersectNext() const
{
  return myFlagIntersectNext;
}

  template <typename TSegmentComputer>
inline
bool
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::intersectPrevious() const
{
  return myFlagIntersectPrevious;
}



  template <typename TSegmentComputer>
inline
const typename DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::ConstIterator
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::begin() const
{
  return mySegmentComputer.begin();
}

  template <typename TSegmentComputer>
inline
const typename DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::ConstIterator
DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator::end() const
{
  return mySegmentComputer.end();
}



// class GreedySegmentation

// Interface - public :


  template <typename TSegmentComputer>
DGtal::GreedySegmentation<TSegmentComputer>::GreedySegmentation
(const ConstIterator& itb, const ConstIterator& ite, const SegmentComputer& aSegmentComputer)
 : myBegin(itb),
   myEnd(ite),
   myStart(itb),
   myStop(ite),
   myMode("Truncate"),
   mySegmentComputer(aSegmentComputer)
{
}


  template <typename TSegmentComputer>
inline
void
DGtal::GreedySegmentation<TSegmentComputer>::setSubRange
(const ConstIterator& itb, const ConstIterator& ite)
{
  myStart = itb;
  myStop = ite;
  myMode = "Truncate";
}

  template <typename TSegmentComputer>
inline
void
DGtal::GreedySegmentation<TSegmentComputer>::setMode
(const std::string& aMode)
{
  myMode = aMode; 
}



  template <typename TSegmentComputer>
inline
DGtal::GreedySegmentation<TSegmentComputer>::~GreedySegmentation()
{
}


  template <typename TSegmentComputer>
inline
typename DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator 
DGtal::GreedySegmentation<TSegmentComputer>::begin() const
{
  return SegmentComputerIterator(this, mySegmentComputer, true);
}


  template <typename TSegmentComputer>
inline
typename DGtal::GreedySegmentation<TSegmentComputer>::SegmentComputerIterator 
DGtal::GreedySegmentation<TSegmentComputer>::end() const
{
  return SegmentComputerIterator(this, mySegmentComputer, false);
}



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


  template <typename TSegmentComputer>
inline
bool
DGtal::GreedySegmentation<TSegmentComputer>::isValid() const
{
  return true;
}



// Implementation of inline functions                                        //

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

//                                                                           //