ArithmeticalDSSComputerOnSurfels.h

 
#pragma once
 
#if defined(ArithmeticalDSSComputerOnSurfels_RECURSES)
#error Recursive header files inclusion detected in ArithmeticalDSSComputerOnSurfels.h
#else // defined(ArithmeticalDSSComputerOnSurfels_RECURSES)
#define ArithmeticalDSSComputerOnSurfels_RECURSES
 
#if !defined ArithmeticalDSSComputerOnSurfels_h
#define ArithmeticalDSSComputerOnSurfels_h
 
// Inclusions
#include <iostream>
#include <list>
#include "DGtal/base/Exceptions.h"
#include "DGtal/base/Common.h"
#include "DGtal/kernel/SpaceND.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/kernel/BasicPointFunctors.h"
#include "DGtal/kernel/CInteger.h"
#include "DGtal/base/ReverseIterator.h"
#include "DGtal/geometry/curves/ArithmeticalDSS.h"
#include "DGtal/topology/CCellularGridSpaceND.h"
 
 
namespace DGtal
{
  // class ArithmeticalDSSComputerOnSurfels
  template <typename TKSpace, typename TIterator,
    typename TInteger = typename TKSpace::Space::Integer>
  class ArithmeticalDSSComputerOnSurfels
  {
    BOOST_CONCEPT_ASSERT(( concepts::CCellularGridSpaceND< TKSpace > ));
    BOOST_STATIC_ASSERT(( TKSpace::dimension == 3 ));
 
    // ----------------------- inner types ------------------------------
  public:
 
    typedef TKSpace KSpace;
 
    typedef typename KSpace::SCell  SCell; 
 
    typedef TIterator ConstIterator;
    BOOST_CONCEPT_ASSERT(( boost_concepts::ReadableIteratorConcept<ConstIterator> ));
    BOOST_CONCEPT_ASSERT(( boost_concepts::ForwardTraversalConcept<ConstIterator> ));
    BOOST_STATIC_ASSERT(( concepts::ConceptUtils::SameType< SCell, 
                          typename IteratorCirculatorTraits<ConstIterator>::Value >::value ));
    typedef typename KSpace::Space::Point Point3;
 
    typedef PointVector<2, TInteger> Point;
 
    typedef functors::Projector<SpaceND<2,TInteger> > Projector; 
    
    typedef typename Point::Coordinate Coordinate;
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<Coordinate> ));
 
    typedef TInteger Integer;
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<Integer> ));
 
    typedef ArithmeticalDSS<Coordinate, Integer, 4> DSS;
    //we expect that the iterator type returned DGtal points, used in the DSS representation
    BOOST_STATIC_ASSERT(( concepts::ConceptUtils::SameType< Point, typename DSS::Point >::value ));
 
    typedef DSS Primitive;
 
    typedef Point Vector;
 
    typedef ArithmeticalDSSComputerOnSurfels<KSpace,ConstIterator,TInteger> Self;
 
    struct DirectPairExtractor {
 
      virtual Point first(const std::pair<Point,Point>& aPair) const { return aPair.first; }
      virtual Point second(const std::pair<Point,Point>& aPair) const { return aPair.second; }
      
    };
    struct IndirectPairExtractor : public DirectPairExtractor {
      
      Point first(const std::pair<Point,Point>& aPair) const { return  aPair.second; }
      Point second(const std::pair<Point,Point>& aPair) const { return aPair.first; }
 
    }; 
    typedef std::shared_ptr<DirectPairExtractor> PairExtractor;  
    
    typedef ArithmeticalDSSComputerOnSurfels<KSpace,ReverseIterator<ConstIterator>,TInteger> Reverse;
 
    // ----------------------- Standard services ------------------------------
  public:
 
    ArithmeticalDSSComputerOnSurfels();
 
    ArithmeticalDSSComputerOnSurfels(const KSpace& aKSpace, Dimension aDim1, Dimension aDim2, bool aFlagToReverse = false);
    
    void init(const ConstIterator& it);
 
    ArithmeticalDSSComputerOnSurfels ( const ArithmeticalDSSComputerOnSurfels & other );
 
    ArithmeticalDSSComputerOnSurfels& operator= ( const ArithmeticalDSSComputerOnSurfels & other );
 
    Self getSelf() const;
 
    Reverse getReverse() const;
 
    bool operator==( const ArithmeticalDSSComputerOnSurfels & other ) const;
 
    bool operator!=( const ArithmeticalDSSComputerOnSurfels & other ) const;
 
    ~ArithmeticalDSSComputerOnSurfels(){};
 
    // ----------------------- Interface --------------------------------------
  public:
 
    bool isExtendableFront();
 
    bool isExtendableBack();
 
    bool extendFront();
 
    bool extendBack();
 
    bool retractFront();
 
    bool retractBack();
 
    std::pair<Point,Point> getProjectedPointsFromSurfel(SCell const& aSurfel) const; 
 
    Point getNextProjectedPoint(SCell const& aSurfel) const;
    
    Point getPreviousProjectedPoint(SCell const& aSurfel) const; 
 
    // ------------------------- Accessors ------------------------------
    const Primitive& primitive() const;
    Integer a() const;
    Integer b() const;
    Integer mu() const;
    Integer omega() const;
    Point Uf() const;
    Point Ul() const;
    Point Lf() const;
    Point Ll() const;
    Point back() const ;
    Point front() const ;
    ConstIterator begin() const;
    ConstIterator end() const;
 
    bool isValid() const;
 
 
    // ------------------------- Hidden services ------------------------------
  private:
 
    std::pair<Point,Point> getProjectedPointsFromLinel(SCell const& aLinel) const; 
    
    Dimension dimNotIn(Dimension const& aDim1, Dimension const& aDim2) const; 
    
    // ------------------------- Protected Datas ------------------------------
  protected:
 
    const KSpace* myKSpace;
 
    Dimension mySliceAxis1;
    
    Dimension mySliceAxis2;
    
    Dimension myProjectionAxis;
 
    Projector my2DProjector; 
 
    PairExtractor myExtractor; 
    
    DSS myDSS;
    
    ConstIterator myBegin;
    
    ConstIterator myEnd;
 
    // ------------------ Display ------------------------------------------
 
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
 
  }; // end of class ArithmeticalDSSComputerOnSurfels
 
 
template <typename TKSpace, typename TIterator, typename TInteger>
std::ostream&
operator<< ( std::ostream & out,  const ArithmeticalDSSComputerOnSurfels<TKSpace,TIterator,TInteger> & object )
{
  object.selfDisplay( out);
  return out;
}
 
} // namespace DGtal
 
 
// Includes inline functions/methods.
#include "DGtal/geometry/surfaces/ArithmeticalDSSComputerOnSurfels.ih"
 
//                                                                           //
 
#endif // !defined ArithmeticalDSSComputerOnSurfels_h
 
#undef ArithmeticalDSSComputerOnSurfels_RECURSES
#endif // else defined(ArithmeticalDSSComputerOnSurfels_RECURSES)