MaximalSegments.h

#pragma once

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

#define MaximalSegments_RECURSES

#if !defined MaximalSegments_h

#define MaximalSegments_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"

namespace DGtal
{
  namespace deprecated
  {
  // template class MaximalSegments
  template <typename TSegment>
  class MaximalSegments
  {

  public: 

    typedef TSegment Segment;
    typedef  typename TSegment::Reverse ReverseSegment;
    typedef typename TSegment::ConstIterator Iterator;    
    typedef typename ReverseSegment::ConstIterator ReverseIterator;


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



    class SegmentIterator
    {

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

      MaximalSegments<Segment> *myCov;

      Iterator myFront;

      Iterator myBack;

      Segment  mySegment;

    
      bool  myFlagIntersectNext;

      bool  myFlagIntersectPrevious;

      bool  myFlag;

      // ------------------------- Standard services -----------------------
    public:
       friend class MaximalSegments<Segment>;
         
      SegmentIterator( MaximalSegments<Segment> *aCov,
                       const Iterator& aBack,
                       const Segment& aSegment);


      SegmentIterator( const SegmentIterator & aOther );
    
      SegmentIterator& operator=( const SegmentIterator & aOther );
    
      ~SegmentIterator();
    
      // ------------------------- iteration services -------------------------
    public:
      
      Segment operator*() const;

      Segment get() const;

      SegmentIterator& operator++();
      
      bool intersectNext() const;

      bool intersectPrevious() const;

      const Iterator getFront() const;

      const Iterator getBack() const;



      bool operator==( const SegmentIterator & aOther ) const;

      bool operator!=( const SegmentIterator & aOther ) const;

      // ------------------------- hidden services -------------------------
 
      private: 

      template <typename TypeSegment, typename TypeIterator>
      void extension(TypeSegment& aSeg, TypeIterator& it, const TypeIterator& end);

      template <typename TypeSegment, typename TypeIterator>
      void extension(TypeSegment& aSeg, TypeIterator& it);

      template <typename TypeSegment, typename TypeIterator>
      void extensionInLoop(TypeSegment& aSeg, TypeIterator& it, 
                           const TypeIterator& begin, const TypeIterator& end);



      void firstMaximalSegment();

      void nextMaximalSegment();

      bool doesIntersectNext(const Iterator& it);
      
    };


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


    MaximalSegments(){};

    MaximalSegments(const Iterator& beginIt, 
                    const Iterator& endIt, 
                    const Segment& aSegment, 
                    const bool& aFlag);

    void init(const Iterator& beginIt, 
              const Iterator& endIt, 
              const Segment& aSegment, 
              const bool& aFlag);


    ~MaximalSegments();

    typename MaximalSegments::SegmentIterator begin();

    typename MaximalSegments::SegmentIterator end();


    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;

    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:

    Iterator myBegin;

    Iterator myEnd;

    Iterator myFirstMaximalSegmentBack;

    Segment mySegment;

    bool isClosed;


    // ------------------------- Hidden services ------------------------------


  private:

    MaximalSegments ( const MaximalSegments & other );

    MaximalSegments & operator= ( const MaximalSegments & other );

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

  }; // end of class MaximalSegments


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

  } // namespace deprecated
} // namespace DGtal


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

//                                                                           //

#endif // !defined MaximalSegments_h

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