FreemanChain.h

#pragma once

#if defined(FreemanChain_RECURSES)
#error Recursive header files inclusion detected in FreemanChain.h
#else // defined(FreemanChain_RECURSES)

#define FreemanChain_RECURSES

#if !defined FreemanChain_h

#define FreemanChain_h

// Inclusions

#include <iostream>
#include <sstream>
#include <vector>
#include <iterator>
#include "DGtal/kernel/PointVector.h"
#include "DGtal/base/OrderedAlphabet.h"
#include "DGtal/base/Circulator.h"
#include "DGtal/arithmetic/ModuloComputer.h"
//#include "DGtal/io/boards/Board2D.h"
#include "DGtal/base/CConstSinglePassRange.h"



namespace DGtal
{

  // class FreemanChain

  template <typename TInteger>
  class FreemanChain
  {

  public :

    BOOST_CONCEPT_ASSERT(( CInteger<TInteger> ) );
    typedef TInteger Integer;
    typedef FreemanChain<Integer> Self;

    typedef PointVector<2, Integer> Point;
    typedef PointVector<2, Integer> Vector;

    typedef unsigned int Size;
    typedef unsigned int Index;

    // ------------------------- iterator ------------------------------
  public:
    
    // class FreemanChain::ConstIterator
  
    
    class ConstIterator : public 
      std::iterator<std::bidirectional_iterator_tag, Point, int, Point*, Point> 
    {

      // ------------------------- Private data -----------------------

      private:

        const FreemanChain* myFc;

        Index myPos;

        Point  myXY;

        // ------------------------- Standard services -----------------------
      public:

        ConstIterator()
          : myFc( NULL ), myPos( 0 )
        { }

        ConstIterator( const FreemanChain & aChain, Index n =0);


        ConstIterator( const FreemanChain & aChain, Index n, const Point & XY)
          : myFc( &aChain ), myPos( n ), myXY ( XY ) 
        { }

        ConstIterator( const ConstIterator & aOther )
          : myFc( aOther.myFc ), myPos( aOther.myPos ), myXY( aOther.myXY )
        { } 

        ConstIterator& operator= ( const ConstIterator & other );

        ~ConstIterator()
        { }

        // ------------------------- iteration services -------------------------
      public:


        const Point& operator*() const
        {
          return myXY;
        }

        const Point& get() const
        {
          return myXY;
        }

        ConstIterator& operator++()
        {
          this->next();
          return *this;
        }

        ConstIterator operator++(int)
        {
          ConstIterator tmp(*this);
          this->next();
          return tmp;
        }


        void next();

        void nextInLoop();

        Index getPosition() const
        {
          return myPos;
        }


        const FreemanChain * getChain() const
        {
          return myFc;
        }

        //unsigned int getCode() const
        char getCode() const
        {
          ASSERT( myFc != 0 );
          return myFc->code( myPos );
        }


        ConstIterator& operator--()
        {
          this->previous();
          return *this;
        }

        ConstIterator operator--(int)
        {
          ConstIterator tmp(*this);
          this->previous();
          return tmp;
        }


        void previous();


        void previousInLoop();


        bool operator== ( const ConstIterator & aOther ) const
        {
          ASSERT( myFc == aOther.myFc );
          return myPos == aOther.myPos;
        }


        bool operator!= ( const ConstIterator & aOther ) const
        {
          ASSERT( myFc == aOther.myFc );
          return myPos != aOther.myPos;
        }

        bool operator< ( const ConstIterator & aOther ) const 
        {
          ASSERT( myFc == aOther.myFc );
          return myPos < aOther.myPos;
        }

    };


// class CodesRange

class CodesRange
{

  // ------------------------- inner types --------------------------------
public: 

  typedef std::string::const_iterator ConstIterator; 
  typedef std::string::const_reverse_iterator ConstReverseIterator;
  typedef Circulator<ConstIterator> ConstCirculator;
  typedef std::reverse_iterator<ConstCirculator> ConstReverseCirculator;

  // ------------------------- standard services --------------------------------

  CodesRange(){}

  CodesRange(const std::string& aChain ): myChain(aChain){}

  CodesRange( const CodesRange & aOther )
    : myChain( aOther.myChain ){}
  
  CodesRange& operator= ( const CodesRange & other )
  {  
    if ( this != &other )
    {
      myChain = other.myChain;
    }
  return *this;
  }

  ~CodesRange() {}

  std::string::size_type size() const 
  {
    return myChain.size();
  }

  bool isValid() const { return true; }
  
  // ------------------------- display --------------------------------
  void selfDisplay ( std::ostream & out ) const 
  {
    typedef typename IteratorCirculatorTraits<ConstIterator>::Value Value; 
    out << "[FreemanChainCodes]" << std::endl;
    out << "\t"; 
    std::copy( this->begin(), this->end(), ostream_iterator<Value>(out, "") );
    out << std::endl;
  }
  
    friend ostream& operator <<(ostream & out, const CodesRange & object)
    {
      object.selfDisplay( out );
      return out;
    }
  // ------------------------- private data --------------------------------
  private:
  const std::string myChain;
  // ------------------------- iterator services --------------------------------
public:

  ConstIterator begin() const {
    return myChain.begin();
  }

  ConstIterator end() const {
    return myChain.end();
  }

  ConstReverseIterator rbegin() const {
    return myChain.rbegin();
  }

  ConstReverseIterator rend() const {
    return myChain.rend();
  }

  ConstCirculator c() const {
    return ConstCirculator( this->begin(), this->begin(), this->end() );
  }

  ConstReverseCirculator rc() const {
    return ConstReverseCirculator( this->c() );
  }
};

// end of class CodesRange

    CodesRange getCodesRange()
    { 
      return CodesRange(chain); 
    }


    // ----------------------- Standard services ------------------------------
    
  public:

    ~FreemanChain()
    { }

    FreemanChain( const std::string & s = "", TInteger x = 0, TInteger y = 0 );


    FreemanChain( const std::vector<Point>& vectPoints);
    
    
    FreemanChain(std::istream & in );


    FreemanChain( const FreemanChain & other );


    FreemanChain & operator=( const FreemanChain & other );


    bool operator==( const FreemanChain & other) const
    {
      return (chain == other.chain) && ( x0 == other.x0 ) && ( y0 == other.y0 )
        && ( xn == other.xn ) && ( yn == other.yn );
    }

    bool operator!=( const FreemanChain & other) const
    {
      return  !( (*this) == other );
    }


    //unsigned int code( Index pos ) const;
    char code( Index pos ) const;


    Size size() const;


    FreemanChain subChain( Index pos, Size n ) const;


    FreemanChain operator+(const FreemanChain& other) const;


    FreemanChain& operator+=(const FreemanChain& other);


    void computeBoundingBox( TInteger & min_x, TInteger& min_y,
           TInteger& max_x, TInteger& max_y ) const;

    //BK
    typename Self::ConstIterator 
      findQuadrantChange( OrderedAlphabet & A ) const;

    //BK
    typename Self::ConstIterator
      findQuadrantChange4( OrderedAlphabet & A ) const ;


    int isClosed() const ;


    int ccwLoops() const ;


    Point getPoint ( Index pos ) const;
    

    Point firstPoint ( ) const
    {
      return Point(x0,y0);
    }


    Point lastPoint ( ) const
    {
      return Point(xn,yn);
    }


    Vector totalDisplacement() const
    {
      return lastPoint() -  firstPoint();
    }
   

    FreemanChain & extend(char code);

    FreemanChain & retract(Size n = 1);

    





    // ----------------------- Iteration services ------------------------------
    
    ConstIterator begin() const;


    ConstIterator end() const;

    Index next( Index pos ) const;


    Index previous( Index pos ) const;


    // ------------------------- Static services -----------------------
    
  public:

    static void write( std::ostream & out, const FreemanChain & c )
    {
      out << c.x0 << " " << c.y0 << " " << c.chain << endl;
    }


    static void read( std::istream & in, FreemanChain & c );

    template<typename TConstIterator>
    static void readFromPointsRange( const TConstIterator& itBegin, const TConstIterator& itEnd, FreemanChain & c );
    
    template<typename TRange>
    static void readFromPointsRange( const TRange& aRange, FreemanChain & c );
    
    static void getContourPoints(const FreemanChain & fc, 
        std::vector<Point> & aVContour );


    //static void movePointFromFC(Point & aPoint, unsigned int aCode );
    static void movePointFromFC(Point & aPoint, char aCode );


    // Deprecated
    //
    // /**
    //  * @param aZero (returns) the '0' or 'x' letter for quadrant [quadrant].
    //  * @param aOne (returns) the '1' or 'y' letter for quadrant [quadrant].
    //  * @param aQuadrant the quadrant as any of '0', '1', '2', or '3'.
    //  */
    // static void alphabet( char & aZero, char & aOne, char aQuadrant )


    //static unsigned int movement( unsigned int aCode1, unsigned int aCode2,
    //    bool ccw = true ); 
    static char movement( char aCode1, char aCode2,
        bool ccw = true ); 

    static char addToCode( char code, int n);



    // static void displacement( int & dx, int & dy, unsigned int aCode );
    static void displacement( int & dx, int & dy, char aCode );


    // static Point displacement( unsigned int aCode );
    static Point displacement( char aCode );


    // static unsigned int turnedCode( unsigned int aCode, bool ccw = true );
    static char turnedCode( char aCode, bool ccw = true );


    static void pointel2pixel( FreemanChain & aPixChain,
             std::vector<unsigned int> & aPl2pix,
             std::vector<unsigned int> & aPix2pl,
             const FreemanChain & aPlChain )
    {
      innerContour( aPixChain, aPl2pix, aPix2pl, aPlChain, true );
    };

    static void innerContour( FreemanChain & aInnerChain,
            std::vector<unsigned int> & aOuter2inner,
            std::vector<unsigned int> & aInner2outer,
            const FreemanChain & aOuterChain,
            bool ccw = true );

    static void cleanContour( std::vector<FreemanChain> & aCleanCs,
            std::vector< std::pair<unsigned int, unsigned int> > & aC2clean,
            std::vector< std::vector<unsigned int> > & aClean2c,
            const FreemanChain & c,
            bool ccw = true )
    {
      // \TODO not implemented yet.
    }

    static bool cleanOuterSpikes( FreemanChain & aCleanC,
          std::vector<unsigned int> & aC2clean,
          std::vector<unsigned int> & aClean2c,
          const FreemanChain & c,
          bool ccw = true );
    



    // ----------------------- Interface --------------------------------------
    
  public:

    void selfDisplay ( std::ostream & out ) const ;


    bool isValid() const ;



    // ----------------------- Drawing services --------------------------------

  public:

    //DrawableWithBoard2D* defaultStyle( std::string mode = "" ) const;
 

    std::string className() const;

    // ------------------------- Public Datas ------------------------------

  public:
    std::string chain;

    Integer x0;

    Integer y0;

    Integer xn;

    Integer yn;

    
    // ------------------------- Internals ------------------------------------
    

  private:

   // FreemanChain() {};

    void computeLastPoint();

  public:


  }; // end of class FreemanChain




  template<typename TInteger>
    std::ostream&
    operator<< ( std::ostream & out, const FreemanChain<TInteger> & object );


} // namespace DGtal


// Includes inline functions/methods.
#include "DGtal/geometry/curves/FreemanChain.ih"

//                                                                           //

#endif // !defined FreemanChain_h

#undef FreemanChain_RECURSES
#endif // else defined(FreemanChain_RECURSES)