GreedyDecomposition.h

#pragma once

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

#define GreedyDecomposition_RECURSES

#if !defined GreedyDecomposition_h

#define GreedyDecomposition_h

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

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

  public: 

    typedef TSegment Segment;
    typedef typename Segment::ConstIterator Iterator;

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



    class SegmentIterator
    {
           
         // ------------------------- data -----------------------
    private:

      const GreedyDecomposition<TSegment> *myDec;


      Iterator myFront;

      Iterator myBack;


      Segment  mySegment;
      

      bool  myFlagIntersectNext;

      bool  myFlagIntersectPrevious;



      // ------------------------- Standard services -----------------------
    public:
       friend class GreedyDecomposition<TSegment>;
         


      SegmentIterator( const GreedyDecomposition<TSegment> *aDec,
         const typename TSegment::ConstIterator& aBack,
         const TSegment& aSegment);


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

      Segment get() const;

      SegmentIterator& operator++();
      
      void next();

      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: 

      void longestSegment();
      
      bool doesIntersectNext(const Iterator& it);
    };


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

    GreedyDecomposition() {};

    GreedyDecomposition(const Iterator& aBegin, 
                        const Iterator& aEnd, 
                        const Segment& aSegment, 
                        const bool& aFlag);

    void init(const Iterator& aBegin, 
              const Iterator& aEnd, 
              const Segment& aSegment, 
              const bool& aFlag);


    ~GreedyDecomposition();

    typename GreedyDecomposition::SegmentIterator begin() const;

    typename GreedyDecomposition::SegmentIterator end() const;


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

    bool isValid() const;

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

    Iterator myBegin, myEnd;

    Segment mySegment;

    bool isClosed;

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


  private:

    GreedyDecomposition ( const GreedyDecomposition & other );

    GreedyDecomposition & operator= ( const GreedyDecomposition & other );

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

  }; // end of class GreedyDecomposition


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

  } // namespace deprecated
} // namespace DGtal


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

//                                                                           //

#endif // !defined GreedyDecomposition_h

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