SaturatedSegmentation.h

#pragma once

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

#define SaturatedSegmentation_RECURSES

#if !defined SaturatedSegmentation_h

#define SaturatedSegmentation_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 SaturatedSegmentation
  template <typename TSegmentComputer>
  class SaturatedSegmentation
  {

  public: 

    BOOST_CONCEPT_ASSERT(( CForwardSegmentComputer<TSegmentComputer> ));
    typedef TSegmentComputer SegmentComputer;
    typedef typename SegmentComputer::ConstIterator ConstIterator;

  private: 

    typedef typename TSegmentComputer::Reverse ReverseSegmentComputer;
    typedef typename ReverseSegmentComputer::ConstIterator ConstReverseIterator;

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



  // template class SegmentComputerIterator
    class SegmentComputerIterator
    {

         // ------------------------- inner Types -----------------------

    public: 
      typedef typename SaturatedSegmentation::SegmentComputer SegmentComputer;
      typedef typename SegmentComputer::ConstIterator ConstIterator;

         // ------------------------- data -----------------------
    private:

      const SaturatedSegmentation<TSegmentComputer> *myS;

      SegmentComputer  mySegmentComputer;
      
      bool  myFlagIsValid;
    
      ConstIterator myLastMaximalSegmentBegin;
      ConstIterator myLastMaximalSegmentEnd;
      
      bool  myFlagIntersectNext;

      bool  myFlagIntersectPrevious;

      bool  myFlagIsLast;



      // ------------------------- Standard services -----------------------
    public:
       friend class SaturatedSegmentation<TSegmentComputer>;
         


      SegmentComputerIterator( const SaturatedSegmentation<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++();
      
      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: 

      

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

      void nextMaximalSegment();

      void initFirstMaximalSegment();

      void initLastMaximalSegment();

    };

    //-------------------------------------------------------------------------
    // end class SegmentComputerIterator
    //-------------------------------------------------------------------------


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

    SaturatedSegmentation() {};

    SaturatedSegmentation(const ConstIterator& itb, 
        const ConstIterator& ite, 
        const SegmentComputer& aSegmentComputer);

    void setSubRange(const ConstIterator& itb, 
                     const ConstIterator& ite);


    void setMode(const std::string& aMode);


    ~SaturatedSegmentation();

    typename SaturatedSegmentation::SegmentComputerIterator begin() const;

    typename SaturatedSegmentation::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:

    SaturatedSegmentation ( const SaturatedSegmentation & other );

    SaturatedSegmentation & operator= ( const SaturatedSegmentation & other );

    // ------------------------- Internals ------------------------------------
  private:

  }; // end of class SaturatedSegmentation


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

} // namespace DGtal


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

//                                                                           //

#endif // !defined SaturatedSegmentation_h

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