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/base/CConstSinglePassRange.h"
#include "DGtal/topology/KhalimskySpaceND.h"
#include "DGtal/base/ConstAlias.h"
 
#include "boost/iterator/reverse_iterator.hpp"
 

 
 
namespace DGtal
{

  // class FreemanChain

 
  template <typename TInteger>
  class FreemanChain
  {
 
  public :
 
    BOOST_CONCEPT_ASSERT(( concepts::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:
      
      using iterator_category = std::bidirectional_iterator_tag;
      using value_type = Point;
      using difference_type = int;
      using pointer = Point*;
      using reference = Point;
      
      // ------------------------- Private data -----------------------
 
      private:

        const FreemanChain* myFc;

        Index myPos;

        Point  myXY;
 
        // ------------------------- Standard services -----------------------
      public:

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

        ConstIterator( ConstAlias<FreemanChain> aChain, Index n =0);
 

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

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

        ConstIterator& operator= ( const ConstIterator & other );

        ~ConstIterator()
        { }
        ~ConstIterator() {…}
 
        // ------------------------- iteration services -------------------------
      public:
 

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

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

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

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

        void next();

        void nextInLoop();

        Index position() const
        {
          return myPos;
        }
        Index position() const {…}
 

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

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

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

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

        void previous();
 

        void previousInLoop();
 

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

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

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

// 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 boost::reverse_iterator<ConstCirculator> ConstReverseCirculator;
 
  // ------------------------- standard services --------------------------------

  CodesRange(){}

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

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

  ~CodesRange() {}

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

  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(), std::ostream_iterator<Value>(out, "") );
    out << std::endl;
  }
  void selfDisplay ( std::ostream & out ) const  {…}
  
  friend std::ostream& operator <<(std::ostream & out, const CodesRange & object)
    {
      object.selfDisplay( out );
      return out;
    }
  friend std::ostream& operator <<(std::ostream & out, const CodesRange & object) {…}
  // ------------------------- private data --------------------------------
  private:    
  std::string myChain;
  // ------------------------- iterator services --------------------------------
public:

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

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

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

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

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

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

// end of class CodesRange

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

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

    ~FreemanChain()
    { }
    ~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 {…}

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

    //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 firstPoint ( ) const {…}
 

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

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

    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 << std::endl;
    }
    static void write( std::ostream & out, const FreemanChain & c ) {…}
 

    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 getInterPixelLinels(const KhalimskySpaceND<2,  TInteger> & aKSpace, 
                                    const FreemanChain & fc, 
                                    typename KhalimskySpaceND<2, TInteger>::SCellSet & aSCellContour,
                                    bool aFlagForAppend=false);
    
 
    
    
    //static void movePointFromFC(Point & aPoint, unsigned int aCode );
    static void movePointFromFC(Point & aPoint, char aCode );

    //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 short freemanCode4C(int dx, int dy);
 
    

    // 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 pointel2pixel( FreemanChain & aPixChain, {…}

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

    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
  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)