FP.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.

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


template <typename TIterator, typename TInteger, int connectivity>
template<typename DSS, typename Adapter>
inline
bool 
DGtal::FP<TIterator,TInteger,connectivity>
::initConvexityConcavity( DSS &aDSS,  
                          Adapter* &anAdapter,
                          const typename DSS::ConstIterator& i ) {

  bool flag; 
  if ( aDSS.getRemainder(i) < (aDSS.getMu()) ) {      //concave part
    flag = false;
    anAdapter = new Adapter4ConcavePart<DSS>(aDSS);
  } else {                                            //convex part
    flag = true;
    anAdapter = new Adapter4ConvexPart<DSS>(aDSS);
  }
  return flag;
}

template <typename TIterator, typename TInteger, int connectivity>
template<typename DSS, typename Adapter>
inline
void 
DGtal::FP<TIterator,TInteger,connectivity>
::mainAlgorithm( DSS &currentDSS, Adapter* adapter, 
                 bool isConvex, 
                 typename DSS::ConstIterator i, 
                 const typename DSS::ConstIterator& end )  throw( InputException ) {

  ASSERT(adapter != 0);

  //std::cerr << "first DSS" << std::endl;
  //std::cerr << currentDSS << std::endl;

  while (i != end) {

    //store the last leaning point 
    //if the first and last leaning points 
    //of the MS are not confounded
    if (adapter->firstLeaningPoint() != adapter->lastLeaningPoint()) {
      myPolygon.push_back(adapter->lastLeaningPoint());
    }

    //removing step
    while (!currentDSS.isExtendableForward(i)) {
      //remove a point from the back
      if ( currentDSS.retractForward() ) {
        //store the last leaning point
        if (adapter->lastLeaningPoint() != myPolygon.back()) {
          myPolygon.push_back(adapter->lastLeaningPoint());
        }
      } else {
        //disconnected digital curve
        throw InputException();
      }
    }

    //remove the last leaning point 
    //if the first and last leaning points 
    //of the current DSS are not confounded
    if (adapter->firstLeaningPoint() != adapter->lastLeaningPoint()) {
      myPolygon.pop_back();
    }    

    //adding step
    while ( (i != end)&&(currentDSS.extendForward(i)) ) {
      //store the first leaning point
      if (adapter->firstLeaningPoint() != myPolygon.back()) {
        myPolygon.push_back(adapter->firstLeaningPoint());
      }
      ++i; //move forward
    }

    //transition step
    if (i != end) {

      if ( (isConvex)&&( currentDSS.getRemainder(i) < 
                         (currentDSS.getMu()) ) ) {
        //from convex to concave
        isConvex = false;
        delete (adapter);
        adapter = new Adapter4ConcavePart<DSS>(currentDSS);
      } else if ( (!isConvex)&&( currentDSS.getRemainder(i) >= 
                                 (currentDSS.getMu()+currentDSS.getOmega()) ) ) {
        //from concave to convex
        isConvex = true;
        delete (adapter);
        adapter = new Adapter4ConvexPart<DSS>(currentDSS);
      }
    }

  }

  //std::cerr << "last DSS" << std::endl;
  //std::cerr << currentDSS << std::endl;

  //last removing step
  while (currentDSS.retractForward()) {
    //store the last leaning point
    if (adapter->lastLeaningPoint() != myPolygon.back()) {
      myPolygon.push_back(adapter->lastLeaningPoint());
    }
  }

}


template <typename TIterator, typename TInteger, int connectivity>
inline
DGtal::FP<TIterator,TInteger,connectivity>::FP(
                                               const TIterator& itb, 
                                               const TIterator& ite ) throw( InputException ) 
{
  FP(itb, ite, false);
}
  
template <typename TIterator, typename TInteger, int connectivity>
inline
DGtal::FP<TIterator,TInteger,connectivity>::FP(
                                               const TIterator& itb, 
                                               const TIterator& ite, 
                                               const bool& isClosed ) throw( InputException ) 
  : myFlagIsClosed( isClosed ) 
{

  TIterator i = itb;
  if (i != ite) 
    {
      if (myFlagIsClosed) 
        { 
          //first maximal DSS
          Circulator<TIterator> citb(i,itb,ite);
          //DSSComputerInLoop firstMS(citb);
          DSSComputerInLoop *firstMS=new DSSComputerInLoop(citb); //init

          ASSERT(firstMS);
        
          //backward extension
          Circulator<TIterator> back( citb );
          do {
            --back; 
          } while (firstMS->extendBackward(back));
          //forward extension
          Circulator<TIterator> front( citb );
          do {
            ++front; 
          } while (firstMS->extendForward(front));

          //local convexity
          bool isConvexAtFront; 
          Adapter<DSSComputerInLoop>* adapterAtFront;   
        
          isConvexAtFront = initConvexityConcavity<DSSComputerInLoop,Adapter<DSSComputerInLoop> >
            (*firstMS,adapterAtFront,front);
        
          bool isConvexAtBack; 
          Adapter<DSSComputerInLoop>* adapterAtBack;  
        
          isConvexAtBack = initConvexityConcavity<DSSComputerInLoop,Adapter<DSSComputerInLoop> >
            (*firstMS,adapterAtBack,back);
        
          ASSERT(adapterAtFront);
          ASSERT(adapterAtBack);
        
        
          //first point 
          if (adapterAtFront->firstLeaningPoint() == adapterAtFront->lastLeaningPoint()) {
            myPolygon.push_back(adapterAtFront->lastLeaningPoint());
          }
        
          //set end iterator
          typename DSSComputerInLoop::Point leaningPoint; 
          if ( ( (isConvexAtFront)&&(isConvexAtBack) ) 
               || ( (!isConvexAtFront)&&(!isConvexAtBack) ) ) {
            leaningPoint = adapterAtFront->lastLeaningPoint();
          } else {
            leaningPoint = adapterAtBack->firstLeaningPoint(); 
          }
          do {
            ++back;
          } while (*back != leaningPoint);
          ++back;
        
          //call main algo
          mainAlgorithm<DSSComputerInLoop,Adapter<DSSComputerInLoop> >
            (*firstMS,adapterAtFront,isConvexAtFront,front,back);
        
          ASSERT(adapterAtFront);
          ASSERT(adapterAtBack);
        
          //delete (adapterAtFront);
          //delete (adapterAtBack);
          delete (firstMS);
          //remove the last point
          myPolygon.pop_back();
        
        } 
      else 
        { 
          //list of successive upper (U) and lower (L)
          // leaning points. 
          std::list<Point> vTmpU, vTmpL;
          vTmpU.push_back(*i);
          vTmpL.push_back(*i);

          //longest DSS
          DSSComputer *longestDSS= new DSSComputer(i); //longest DSS
          
          ASSERT(longestDSS);

          ++i; //move forward
          while ( (i != ite)&&(longestDSS->extendForward(i)) ) 
            {
              //store the first upper leaning point
              if (longestDSS->getUf() != vTmpU.back()) {
                vTmpU.push_back(longestDSS->getUf());
              }
              //store the first lower leaning point
              if (longestDSS->getLf() != vTmpL.back()) {
                vTmpL.push_back(longestDSS->getLf());
              }
              ++i; //move forward
            }
        
          bool isConvex; //TRUE if longestDSS begins a convex part, FALSE otherwise
          Adapter<DSSComputer>* adapter; //adapter for the current DSS
        
          if (i != ite) 
            {
              isConvex = initConvexityConcavity<DSSComputer,Adapter<DSSComputer> >
                (*longestDSS,adapter,i);
            
              ASSERT(adapter);
            
              if (isConvex) myPolygon = vTmpU;
              else myPolygon = vTmpL;
            
              //call main algo
              mainAlgorithm<DSSComputer,Adapter<DSSComputer> >
                (*longestDSS,adapter,isConvex,i,ite);
            
              ASSERT(adapter);
              //delete (adapter);
              delete (longestDSS);
            } 
          else 
            {
              //the part is assumed to be convex
              //if it is straight
              myPolygon = vTmpU;
              isConvex = true;
              adapter = new Adapter4ConvexPart<DSSComputer>(*longestDSS);
              ASSERT(adapter);
            }
        
        }//end closed/open test
    
    } //end itb == ite test
  
}

template <typename TIterator, typename TInteger, int connectivity>
inline
DGtal::FP<TIterator,TInteger,connectivity>::~FP()
{
}

// Interface - public :

template <typename TIterator, typename TInteger, int connectivity>
inline
bool
DGtal::FP<TIterator,TInteger,connectivity>::isValid() const
{
  return true;
}

template <typename TIterator, typename TInteger, int connectivity>
inline
typename FP<TIterator,TInteger,connectivity>::Polygon::size_type
DGtal::FP<TIterator,TInteger,connectivity>::size() const
{
  return myPolygon.size();
}


template <typename TIterator, typename TInteger, int connectivity>
template <typename OutputIterator>
inline
OutputIterator
DGtal::FP<TIterator,TInteger,connectivity>::copyFP(OutputIterator result) const {
  typename Polygon::const_iterator i = myPolygon.begin();
  while ( i != myPolygon.end() ) {
    *result++ = *i++;
  }
  return result;
}

template <typename TIterator, typename TInteger, int connectivity>
template <typename OutputIterator>
inline
OutputIterator
DGtal::FP<TIterator,TInteger,connectivity>::copyMLP(OutputIterator result) const {

  unsigned int n = (unsigned int) myPolygon.size();
  if (n < 3) { //special case < 3 points

    typename Polygon::const_iterator i = myPolygon.begin();
    for ( ; i!= myPolygon.end() ; ++i) {
      *result++ = RealPoint( *i );
    }

  } else {    //standard case

    typename Polygon::const_iterator i, j, k;
    i = myPolygon.begin();
    j = i; ++j; 
    k = j; ++k; 

    if (myFlagIsClosed) { 

      //first point
      *result++ = getRealPoint(myPolygon.back(),*i,*j);
      //middle points
      while ( k != myPolygon.end() ) {
        *result++ = getRealPoint(*i,*j,*k);
        ++i; ++j; ++k; 
      }
      //last point
      *result++ = getRealPoint(*i,*j,myPolygon.front());

    } else { 

      //first point
      *result++ = RealPoint( myPolygon.front() );
      //middle points
      while ( k != myPolygon.end() ) {
        *result++ = getRealPoint(*i,*j,*k);
        ++i; ++j; ++k; 
      }
      //last point
      *result++ = RealPoint( myPolygon.back() );

    }

  }
  return result;
}

template <typename TIterator, typename TInteger, int connectivity>
inline
DGtal::PointVector<2,double>
DGtal::FP<TIterator,TInteger,connectivity>
::getRealPoint (const Point& a,const Point& b, const Point& c) const {

  RealVector shift;

  Vector e1 = b - a; //previous edge
  Vector e2 = c - b; //next edge

  if ( (e1[0]*e2[1]-e1[1]*e2[0]) <= 0 ) {

    //convex turn
    if ( (quadrant(e1,1))&&(quadrant(e2,1)) ) {
      shift = RealVector(0.5,-0.5);
    } else if ( (quadrant(e1,2))&&(quadrant(e2,2)) ) {
      shift = RealVector(-0.5,-0.5);
    } else if ( (quadrant(e1,3))&&(quadrant(e2,3)) ) {
      shift = RealVector(-0.5,0.5);
    } else if ( (quadrant(e1,4))&&(quadrant(e2,4)) ) {
      shift = RealVector(0.5,0.5);
    } else {
      ASSERT(false && "DGtal::FP<TIterator,TInteger,connectivity>::getRealPoint: not valid polygon" );
    }

  } else {

    //concave turn
    if ( (quadrant(e1,1))&&(quadrant(e2,1)) ) {
      shift = RealVector(-0.5,0.5);
    } else if ( (quadrant(e1,2))&&(quadrant(e2,2)) ) {
      shift = RealVector(0.5,0.5);
    } else if ( (quadrant(e1,3))&&(quadrant(e2,3)) ) {
      shift = RealVector(0.5,-0.5);
    } else if ( (quadrant(e1,4))&&(quadrant(e2,4)) ) {
      shift = RealVector(-0.5,-0.5);
    } else {
      ASSERT(false && "DGtal::FP<TIterator,TInteger,connectivity>::getRealPoint: not valid polygon" );
    }

  } 

  return ( RealPoint(b) + shift );
}

template <typename TIterator, typename TInteger, int connectivity>
inline
bool
DGtal::FP<TIterator,TInteger,connectivity>
::quadrant (const Vector& v, const int& q) const {

  if (q == 1) {
    return ( (v[0]>=0)&&(v[1]>=0) );
  } else if (q == 2) {
    return ( (v[0]>=0)&&(v[1]<=0) );
  } else if (q == 3) {
    return ( (v[0]<=0)&&(v[1]<=0) );
  } else if (q == 4) {
    return ( (v[0]<=0)&&(v[1]>=0) );
  } else {
    ASSERT(false && 
           "DGtal::FP<TIterator,TInteger,connectivity>::quadrant: quadrant number should be 0,1,2 or 3"  );
    return false;
  }
}

// Display :

template <typename TIterator, typename TInteger, int connectivity>
inline
std::string
DGtal::FP<TIterator,TInteger,connectivity>::className() const
{
  return "FP";
} 


template <typename TIterator, typename TInteger, int connectivity>
inline
void
DGtal::FP<TIterator,TInteger,connectivity>::selfDisplay ( std::ostream & out ) const
{
  out << "[FP]" << endl;
  typename Polygon::const_iterator i = myPolygon.begin();
  for ( ;i != myPolygon.end();++i)
    {
      out << "\t " << (*i) << endl;
    }              
  out << "[end FP]" << endl;
}





// Implementation of inline functions                                        //

template <typename TIterator, typename TInteger, int connectivity>
inline
std::ostream&
DGtal::operator<< ( std::ostream & out, 
                    const FP<TIterator,TInteger,connectivity> & object )
{
  object.selfDisplay( out );
  return out;
}

//                                                                           //