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/PointVector.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,
    unsigned short adjacency = 8>
  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 typename KSpace::Cell  Cell; 
 
    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 typename Point::Coordinate Coordinate;
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<Coordinate> ));
 
    typedef TInteger Integer;
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<Integer> ));
 
    typedef ArithmeticalDSS<Coordinate, Integer, adjacency> 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,adjacency> Self;
    typedef ArithmeticalDSSComputerOnSurfels<KSpace,ReverseIterator<ConstIterator>,TInteger,adjacency> Reverse;
 
    // ----------------------- Standard services ------------------------------
  public:
 
    ArithmeticalDSSComputerOnSurfels();
 
    ArithmeticalDSSComputerOnSurfels(const KSpace& aKSpace, Dimension aDim1, Dimension aDim2);
 
    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();
 
 
    // ------------------------- 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;
 
    std::pair<Point, Point> projectSurfel(SCell const& aSCell) const;
 
    // ------------------------- Hidden services ------------------------------
  private:
    bool commonLinel (Cell const& aSurfel1, Cell const& aSurfel2, Cell& aLinel);
 
    Point projectInPlane (Point3 const& aPoint) const;
 
    bool getOtherPointFromSurfel (ConstIterator const& it, Point& aPoint, bool aIsFront, bool aUpdatePrevious);
 
    // ------------------------- Protected Datas ------------------------------
  protected:
 
    const KSpace* myKSpace;
 
    Dimension myDim1;
 
    Dimension myDim2;
 
    Point3 myProjection1;
 
    Point3 myProjection2;
 
    Point3 myProjectionNormal;
 
    ConstIterator myPreviousSurfelFront;
 
    ConstIterator myPreviousSurfelBack;
 
    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, unsigned short adjacency>
std::ostream&
operator<< ( std::ostream & out,  const ArithmeticalDSSComputerOnSurfels<TKSpace,TIterator,TInteger,adjacency> & 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)