GreedySegmentation.h

 
#pragma once
 
#if defined(GreedySegmentation_RECURSES)
#error Recursive header files inclusion detected in GreedySegmentation.h
#else // defined(GreedySegmentation_RECURSES)
#define GreedySegmentation_RECURSES
 
#if !defined GreedySegmentation_h
#define GreedySegmentation_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/geometry/curves/SegmentComputerUtils.h"
#include "DGtal/geometry/curves/CForwardSegmentComputer.h"
 
 
namespace DGtal
{
  
  // template class GreedySegmentation
  template <typename TSegmentComputer>
  class GreedySegmentation
  {
 
  public: 
 
    BOOST_CONCEPT_ASSERT(( concepts::CForwardSegmentComputer<TSegmentComputer> ) );
    typedef TSegmentComputer SegmentComputer;
    typedef typename SegmentComputer::ConstIterator ConstIterator;
 
    // ----------------------- Standard services ------------------------------
  public:
 
 
 
  // template class SegmentComputerIterator
    class SegmentComputerIterator
    {
 
         // ------------------------- inner Types -----------------------
 
    public: 
      typedef typename GreedySegmentation::SegmentComputer SegmentComputer;
      typedef typename SegmentComputer::ConstIterator ConstIterator;
 
         // ------------------------- data -----------------------
    private:
 
      const GreedySegmentation<TSegmentComputer> *myS;
 
      SegmentComputer  mySegmentComputer;
      
      bool  myFlagIsValid;
    
      bool  myFlagIntersectNext;
 
      bool  myFlagIntersectPrevious;
 
      bool  myFlagIsLast;
 
      
 
      // ------------------------- Standard services -----------------------
    public:
       friend class GreedySegmentation<TSegmentComputer>;
         
 
 
      SegmentComputerIterator( const GreedySegmentation<TSegmentComputer> *aSegmentation,
         const TSegmentComputer& aSegmentComputer,
         const bool& aFlag );
 
 
      SegmentComputerIterator( const SegmentComputerIterator & aOther );
    
      SegmentComputerIterator& operator=( const SegmentComputerIterator & aOther );
    
      ~SegmentComputerIterator();
 
      bool isValid() const { return myFlagIsValid; }
    
      // ------------------------- iteration services -------------------------
    public:
      
      const SegmentComputer& operator*() const;
 
 
      SegmentComputer get() const;
 
 
      const SegmentComputer* operator->() const;
 
      SegmentComputerIterator& operator++();
      
      void next();
 
 
      bool operator==( const SegmentComputerIterator & aOther ) const;
 
      bool operator!=( const SegmentComputerIterator & aOther ) const;
 
    // ----------------------- accessors --------------------------------------
 
      bool intersectNext() const;
 
      bool intersectPrevious() const;
 
      const ConstIterator begin() const;
 
      const ConstIterator end() const;
 
    // ----------------------- hidden services --------------------------------------
 
      private: 
 
      void longestSegment(const ConstIterator& it);
      
      bool doesIntersectNext(const ConstIterator& it, 
                       const ConstIterator& itb, const ConstIterator& ite);
      bool doesIntersectNext(const ConstIterator& it, 
                       const ConstIterator& itb, const ConstIterator& ite, IteratorType);
      bool doesIntersectNext(const ConstIterator& it, 
                       const ConstIterator& itb, const ConstIterator& ite, CirculatorType);
 
      bool doesIntersectNext(const ConstIterator& it);
 
 
    };
 
 
    // ----------------------- Interface --------------------------------------
  public:
 
    GreedySegmentation() {};
 
    GreedySegmentation(const ConstIterator& itb, 
                        const ConstIterator& ite, 
                        const SegmentComputer& aSegmentComputer);
 
    void setSubRange(const ConstIterator& itb, 
                     const ConstIterator& ite);
 
 
    void setMode(const std::string& aMode);
 
 
    ~GreedySegmentation();
 
    typename GreedySegmentation::SegmentComputerIterator begin() const;
 
    typename GreedySegmentation::SegmentComputerIterator end() const;
 
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:
 
    ConstIterator myBegin;
    
    ConstIterator myEnd;
  
    ConstIterator myStart;
 
    ConstIterator myStop;
  
    std::string myMode; 
 
    SegmentComputer mySegmentComputer;
 
    // ------------------------- Hidden services ------------------------------
 
 
  private:
 
    GreedySegmentation ( const GreedySegmentation & other );
 
    GreedySegmentation & operator= ( const GreedySegmentation & other );
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class GreedySegmentation
 
 
  template <typename SegmentComputer>
  std::ostream&
  operator<< ( std::ostream & out, const GreedySegmentation<SegmentComputer> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/curves/GreedySegmentation.ih"
 
//                                                                           //
 
#endif // !defined GreedySegmentation_h
 
#undef GreedySegmentation_RECURSES
#endif // else defined(GreedySegmentation_RECURSES)