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/CForwardSegmentComputer.h"


namespace DGtal
{
  
  // template class GreedySegmentation
  template <typename TSegmentComputer>
  class GreedySegmentation
  {

  public: 

    BOOST_CONCEPT_ASSERT(( 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)