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"
 
 
 
 
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( ConstAlias<FreemanChain> aChain, Index n =0);
 
 
        ConstIterator( ConstAlias<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 position() 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(), std::ostream_iterator<Value>(out, "") );
    out << std::endl;
  }
  
  friend std::ostream& operator <<(std::ostream & out, const CodesRange & object)
    {
      object.selfDisplay( out );
      return out;
    }
  // ------------------------- private data --------------------------------
  private:
  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 << std::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 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 );
 
 
    // 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 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 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
 
 
 
 
  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)