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(( concepts::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)