GridCurve.h

#pragma once

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

#define GridCurve_RECURSES

#if !defined GridCurve_h

#define GridCurve_h

// Inclusions
#include <iostream>
#include <sstream>
#include <vector>
#include <iterator>
#include <cstddef>
#include <utility>

#include "DGtal/base/Common.h"
#include "DGtal/io/readers/PointListReader.h"
#include "DGtal/base/ConstAlias.h"

#include "DGtal/base/BasicFunctors.h"
#include "DGtal/base/Circulator.h"
#include "DGtal/base/ConstRangeAdapter.h"
#include "DGtal/base/ConstIteratorAdapter.h"

#include "DGtal/topology/CCellularGridSpaceND.h"
#include "DGtal/topology/KhalimskySpaceND.h"
#include "DGtal/topology/SCellsFunctors.h"
#include "DGtal/topology/CanonicSCellEmbedder.h"


namespace DGtal
{



  // class GridCurve

  template <typename TKSpace = KhalimskySpaceND<2> >
  class GridCurve
  {

  public: 
    typedef TKSpace KSpace; 
    BOOST_CONCEPT_ASSERT(( concepts::CCellularGridSpaceND< KSpace > )); 
  
    typedef typename KSpace::Point Point;
    typedef typename KSpace::Point Vector;

    typedef typename KSpace::SCell SCell;
    typedef typename std::vector<SCell> Storage; 

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

    ~GridCurve();

    GridCurve( ConstAlias<KSpace> aKSpace);

    GridCurve();

    GridCurve( const GridCurve & other );

    GridCurve & operator=( const GridCurve & other );

    // ----------------------- common ------------------------------

    std::string className() const;

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

    bool isValid() const;

    // ----------------------- streams ------------------------------

    bool initFromVectorStream(std::istream & in );

    void writeVectorToStream( std::ostream & out );

    // ----------------------- Initializations ------------------------------

    bool initFromVector( const std::vector<Point>& aVectorOfPoints );

    bool initFromPointsVector( const std::vector<Point>& aVectorOfPoints ); 

    template <typename TIterator>
    bool initFromPointsRange( const TIterator& itb, const TIterator& ite );

    bool initFromSCellsVector( const std::vector<SCell>& aVectorOfSCells );

    template <typename TIterator>
    bool initFromSCellsRange( const TIterator& itb, const TIterator& ite );


    // ----------------------- open/closed ------------------------------


    bool isClosed() const;

    bool isOpen() const;

    // ----------------------- container interface ------------------------------

    typedef typename Storage::const_iterator const_iterator; 
    typedef typename Storage::const_iterator ConstIterator; 
    typedef typename Storage::const_reverse_iterator const_reverse_iterator; 
    typedef typename Storage::const_reverse_iterator ConstReverseIterator; 

    ConstIterator begin() const; 

    ConstIterator end() const; 
     
    ConstReverseIterator rbegin() const; 

    ConstReverseIterator rend() const; 

    SCell back() const; 

    void push_back(const SCell& aSCell); 

    void pushBack(const SCell& aSCell); 

    typename Storage::size_type size() const; 

    // ------------------------- private Datas --------------------------------
  private:
    const KSpace* myKPtr;
    bool myFlagIsOwned;

    Storage mySCells; 


    // ------------------------- Public Datas --------------------------------
  public:



    // ------------------------- Internal --------------------------------
  private:

    SCell PointVectorTo1SCell(const Point& aPoint, const Vector& aVector);
    bool isInside(const SCell& aSCell) const;
    

    
    // ------------------------- inner classes --------------------------------

  public: 


    typedef ConstRangeAdapter< typename Storage::const_iterator, functors::Identity, SCell >  SCellsRange;

    SCellsRange getSCellsRange() const {
      return SCellsRange(mySCells.begin(), mySCells.end(), new functors::Identity() );
    } 


    typedef ConstRangeAdapter< typename Storage::const_iterator, functors::SCellToPoint<KSpace>, Point >  PointsRange;

    PointsRange getPointsRange() const {
      return PointsRange(mySCells.begin(), mySCells.end(), new functors::SCellToPoint<KSpace>(*myKPtr) );
    } 


    typedef ConstRangeAdapter< typename Storage::const_iterator, CanonicSCellEmbedder<KSpace>,
                               typename KSpace::Space::RealPoint >  MidPointsRange; 

    MidPointsRange getMidPointsRange() const {
      return MidPointsRange(mySCells.begin(), mySCells.end(), new CanonicSCellEmbedder<KSpace>(*myKPtr) );
    } 


    typedef ConstRangeAdapter< typename Storage::const_iterator, functors::SCellToArrow<KSpace>, 
                               std::pair<Point,Vector> >  ArrowsRange; 

    ArrowsRange getArrowsRange() const {
      return ArrowsRange(mySCells.begin(), mySCells.end(), new functors::SCellToArrow<KSpace>(*myKPtr) );
    } 


    typedef ConstRangeAdapter< typename Storage::const_iterator, functors::SCellToInnerPoint<KSpace>, 
                               Point >  InnerPointsRange; 

    InnerPointsRange getInnerPointsRange() const {
      return InnerPointsRange(mySCells.begin(), mySCells.end(), new functors::SCellToInnerPoint<KSpace>(*myKPtr) );
    } 


    typedef ConstRangeAdapter< typename Storage::const_iterator, functors::SCellToOuterPoint<KSpace>, 
                               Point >  OuterPointsRange; 

    OuterPointsRange getOuterPointsRange() const {
      return OuterPointsRange(mySCells.begin(), mySCells.end(), new functors::SCellToOuterPoint<KSpace>(*myKPtr) );
    } 


    typedef ConstRangeAdapter< typename Storage::const_iterator, functors::SCellToIncidentPoints<KSpace>, 
                               std::pair<Point, Point> >  IncidentPointsRange; 

    IncidentPointsRange getIncidentPointsRange() const {
      return IncidentPointsRange(mySCells.begin(), mySCells.end(), new functors::SCellToIncidentPoints<KSpace>(*myKPtr) );
    } 

    typedef ConstRangeAdapter< typename Storage::const_iterator, functors::SCellToCode<KSpace>, char >  CodesRange; 

    typename GridCurve::CodesRange getCodesRange() const {
      return CodesRange( mySCells.begin(), mySCells.end(), new functors::SCellToCode<KSpace>(*myKPtr) );    
    } 

  }; // end of class GridCurve



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


} // namespace DGtal


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

//                                                                           //

#endif // !defined GridCurve_h

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