StabbingCircleComputer.h

 
#pragma once

 
#if defined(StabbingCircleComputer_RECURSES)
#error Recursive header files inclusion detected in StabbingCircleComputer.h
#else // defined(StabbingCircleComputer_RECURSES)
#define StabbingCircleComputer_RECURSES
 
#if !defined StabbingCircleComputer_h
#define StabbingCircleComputer_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/CowPtr.h"
#include "DGtal/base/ConceptUtils.h"
#include "DGtal/geometry/curves/SegmentComputerUtils.h"
 
#include "DGtal/geometry/curves/StabbingLineComputer.h"
#include "DGtal/shapes/fromPoints/CircleFrom2Points.h"
#include "DGtal/geometry/tools/Preimage2D.h"
#include "DGtal/shapes/fromPoints/CircleFrom3Points.h"
#include "DGtal/shapes/fromPoints/Point2ShapePredicate.h"
#include "boost/iterator/reverse_iterator.hpp"

 
namespace DGtal
{

  // template class StabbingCircleComputer
  template <typename TConstIterator>
  class StabbingCircleComputer
  {
 
  public:
 
    //required types
    typedef TConstIterator ConstIterator;
    typedef StabbingCircleComputer<ConstIterator> Self;
    typedef StabbingCircleComputer<ReverseIterator<ConstIterator> > Reverse;
 
    //point type
    typedef typename IteratorCirculatorTraits<ConstIterator>::Value Pair;
    //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 ));
    typedef typename Pair::first_type Point;
    BOOST_STATIC_ASSERT(( Point::dimension == 2 ));
 
  private:
 
    //other types used for the recognition
    typedef CowPtr<StabbingLineComputer<ConstIterator> > StabbingLineComputerPtr;
    typedef CircleFrom3Points<Point> Circle;
 
    //Predicates used to decide whether the current circle is still separating or not
    typedef functors::Point2ShapePredicate<Circle,false,true>
      PInCirclePred;
    typedef functors::Point2ShapePredicate<Circle,true,true>
      QInCirclePred;
 
    // ----------------------- Standard services ------------------------------
  public:

    StabbingCircleComputer();

    StabbingCircleComputer ( const Self& other );

    Self& operator= ( const Self& other );

    ~StabbingCircleComputer();

    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 -------------------------------

    bool isStraight() const;

    StabbingLineComputerPtr getStabbingLineComputerPtr() const;

    Circle getSeparatingCircle() const;
 
    // ----------------------- growth operations --------------------------------------

    void init(const ConstIterator& anIt);

    bool extendFront();

    bool isExtendableFront();

    bool extendBack();

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

    std::string className() const;
 
 
    // ------------------------- Protected Data ------------------------------
  private:
    // ------------------------- Private Data --------------------------------
  private:
    ConstIterator myBegin;
    ConstIterator myEnd;
    StabbingLineComputerPtr mySegPtr;
    Circle myCircle;
    bool myFlagIsInit;
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
 
  private:
 
 
    // ------------------------- Internals ------------------------------------
  private:

    template <typename TIterator>
    bool isCircularlySeparable(const TIterator& itb, const TIterator& ite,
                               const Point& aPole,
                               Point& Pf, Point& Pl, Point& Qf, Point& Ql);
 
    // ------------------------- Private Data --------------------------------
  private:
 
 
  }; // end of class StabbingCircleComputer
 

  template <typename TConstIterator>
  std::ostream&
  operator<< ( std::ostream & out, const StabbingCircleComputer<TConstIterator> & object );
 
} // namespace DGtal
 

// Includes inline functions.
#include "DGtal/geometry/curves/StabbingCircleComputer.ih"
 
//                                                                           //
 
#endif // !defined StabbingCircleComputer_h
 
#undef StabbingCircleComputer_RECURSES
#endif // else defined(StabbingCircleComputer_RECURSES)