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)