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 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() );
    } 
    SCellsRange getSCellsRange() const  {…}

 
    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) );
    } 
    PointsRange getPointsRange() const  {…}

 
    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) );
    } 
    MidPointsRange getMidPointsRange() const  {…}

 
    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) );
    } 
    ArrowsRange getArrowsRange() const  {…}

 
    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) );
    } 
    InnerPointsRange getInnerPointsRange() const  {…}

 
    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) );
    } 
    OuterPointsRange getOuterPointsRange() const  {…}

 
    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) );
    } 
    IncidentPointsRange getIncidentPointsRange() const  {…}

 
    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) );    
    } 
    typename GridCurve::CodesRange getCodesRange() const  {…}
 
  }; // end of class GridCurve
  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)