StabbingLineComputer.h

#pragma once

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

#define StabbingLineComputer_RECURSES

#if !defined StabbingLineComputer_h

#define StabbingLineComputer_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include <boost/static_assert.hpp>
#include "DGtal/base/CowPtr.h"
#include "DGtal/base/ConceptUtils.h"
#include "DGtal/base/ReverseIterator.h"
#include "DGtal/geometry/curves/SegmentComputerUtils.h"

#include "DGtal/geometry/tools/Preimage2D.h"
#include "DGtal/shapes/fromPoints/StraightLineFrom2Points.h"


namespace DGtal
{

  // template class StabbingLineComputer
  template <typename TConstIterator>
  class StabbingLineComputer
  {

  public:

    //requiered types
    typedef TConstIterator ConstIterator;
    typedef StabbingLineComputer<ConstIterator> Self; 
    typedef StabbingLineComputer<ReverseIterator<ConstIterator> > Reverse;

    //point type
    typedef typename IteratorCirculatorTraits<ConstIterator>::Value Pair; 
    typedef typename Pair::first_type Point;

    //Pair::first_type and Pair::second_type should be the same type;
    BOOST_STATIC_ASSERT( ( concepts::ConceptUtils::SameType
                           < typename Pair::first_type, typename Pair::second_type >
                           ::value ) );

    //preimage
    typedef StraightLineFrom2Points<Point> StraightLine; 
    typedef Preimage2D<StraightLine> Preimage; 
    typedef CowPtr<Preimage> PreimagePtr; 

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

    StabbingLineComputer();

    StabbingLineComputer ( const Self& other );

    Self& operator= ( const Self& other );

    ~StabbingLineComputer();

    bool operator==( const Self & other) const;

    bool operator!=( const Self & other) const;

    Self getSelf() const;

     Reverse getReverse() const; 
    

    // ----------------------- Interface --------------------------------------
  public:

    bool isValid() const;

    ConstIterator begin() const;

    ConstIterator end() const;

    // ----------------------- accessors --------------------------------------

    Point Uf() const;

    Point Ul() const;

    Point Lf() const;

    Point Ll() const;

    PreimagePtr getPreimage() const;

    bool isClockwiseOriented() const;

    void getParameters(double& alpha, double& beta, double& gamma) const;
    
    void projects(double& x, double& y, 
                const double& alpha, const double& beta, const double& gamma) const;

    // ----------------------- growth operations --------------------------------------

    void init(const ConstIterator& anIt);

    bool extendFront();

    bool isExtendableFront();

    bool isConcave();

    bool isConvex();

    bool extendBack();

    bool isExtendableBack();

    bool isOppositeEndConcave();

    bool isOppositeEndConvex();

    //------------------ display -------------------------------
    void selfDisplay ( std::ostream & out ) const;

    //DrawableWithBoard2D* defaultStyle( std::string mode="" ) const;
    
    std::string className() const;

    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:
    ConstIterator myBegin;
    ConstIterator myEnd;
    PreimagePtr myPreimagePtr; 
    bool myFlagIsInit; 
    bool myFlagIsCW; 

    // ------------------------- Hidden services ------------------------------
  protected:


  private:

    

    // ------------------------- Internals ------------------------------------
  private:
    
    // ------------------------- Private Datas --------------------------------
  private:

  }; // end of class StabbingLineComputer


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

} // namespace DGtal


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

//                                                                           //

#endif // !defined StabbingLineComputer_h

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