TiledImageBidirectionalRangeFromPoint.h

 
#pragma once

 
#if defined(TiledImageBidirectionalRangeFromPoint_RECURSES)
#error Recursive header files inclusion detected in TiledImageBidirectionalRangeFromPoint.h
#else // defined(TiledImageBidirectionalRangeFromPoint_RECURSES)
#define TiledImageBidirectionalRangeFromPoint_RECURSES
 
#if !defined TiledImageBidirectionalRangeFromPoint_h
#define TiledImageBidirectionalRangeFromPoint_h

// Inclusions
#include "DGtal/base/BasicFunctors.h"
#include "DGtal/base/Circulator.h"
#include "DGtal/base/IteratorAdapter.h"
#include "DGtal/base/CBidirectionalRangeFromPoint.h"
#include "boost/concept_check.hpp"
#include "boost/iterator/reverse_iterator.hpp"
 
namespace DGtal
{
 

  // class TiledImageBidirectionalRangeFromPoint

  template <typename TTiledImage>
 
  class TiledImageBidirectionalRangeFromPoint
  {
 
      BOOST_CONCEPT_ASSERT ( ( boost::BidirectionalIterator<typename TTiledImage::OutputIterator> ) );
      BOOST_CONCEPT_ASSERT ( ( boost::BidirectionalIterator<typename TTiledImage::ConstIterator> ) );
 
      // ------------------------- inner types --------------------------------
 
    public:
 
      typedef TTiledImage TiledImage;
 
      typedef typename TiledImage::Point Point;
 
      typedef typename TiledImage::OutputIterator Iterator;
      typedef typename TiledImage::ConstIterator ConstIterator;
 
      typedef boost::reverse_iterator<Iterator> ReverseIterator;
      typedef boost::reverse_iterator<ConstIterator> ConstReverseIterator;
 
      typedef typename TiledImage::OutputIterator OutputIterator;
      typedef boost::reverse_iterator<Iterator> ReverseOutputIterator;
 
      // typedef Circulator<Iterator> Circulator;
      // typedef boost::reverse_iterator<Circulator> ReverseCirculator;
 
      // ------------------------- standard services --------------------------------

      TiledImageBidirectionalRangeFromPoint ( const TiledImage *ti )
        : myti ( ti ) {}
      TiledImageBidirectionalRangeFromPoint ( const TiledImage *ti ) {…}

      TiledImageBidirectionalRangeFromPoint ( const TiledImageBidirectionalRangeFromPoint & other )
          : myti ( other.myti ) {}
      TiledImageBidirectionalRangeFromPoint ( const TiledImageBidirectionalRangeFromPoint & other ) {…}

      TiledImageBidirectionalRangeFromPoint& operator= ( const TiledImageBidirectionalRangeFromPoint & other )
      {
        if ( this != &other )
        {
          myti = other.myti;
        }
 
        return *this;
      }
      TiledImageBidirectionalRangeFromPoint& operator= ( const TiledImageBidirectionalRangeFromPoint & other ) {…}

      ~TiledImageBidirectionalRangeFromPoint() {}

      bool isValid() const
      {
        return true;
      }
      bool isValid() const {…}
 
      // ------------------------- display --------------------------------
      void selfDisplay ( std::ostream & out ) const
      {
        typedef typename IteratorCirculatorTraits<Iterator>::Value Value;
        out << "[TiledImageBidirectionalRangeFromPoint]" << std::endl;
        out << "\t";
        std::copy ( myti->begin(), myti->end(), std::ostream_iterator<Value> ( out, ", " ) );
        out << std::endl;
      }
      void selfDisplay ( std::ostream & out ) const {…}

      std::string className() const
      {
        return "TiledImageBidirectionalRangeFromPoint";
      }
      std::string className() const {…}
 
 
      // ------------------------- private data --------------------------------
 
    private:
      
      const TTiledImage *myti;
 
      // ------------------------- iterator services --------------------------------
 
    public:

      Iterator begin()
      {
        return Iterator ( myti->begin() );
      }
      Iterator begin() {…}

      Iterator begin ( const Point &aPoint )
      {
        return Iterator ( myti->begin(aPoint) );
      }
      Iterator begin ( const Point &aPoint ) {…}

      ConstIterator begin() const
      {
        return ConstIterator ( myti->begin() );
      }
      ConstIterator begin() const {…}

      ConstIterator begin ( const Point &aPoint ) const
      {
        return ConstIterator ( myti->begin(aPoint) );
      }
      ConstIterator begin ( const Point &aPoint ) const {…}

      Iterator end()
      {
        return Iterator ( myti->end() );
      }
      Iterator end() {…}

      ConstIterator end()  const
      {
        return ConstIterator ( myti->end() );
      }
      ConstIterator end()  const {…}

      OutputIterator outputIterator()
      {
        return OutputIterator ( myti->begin() );
      }
      OutputIterator outputIterator() {…}

      OutputIterator outputIterator ( const Point &aPoint )
      {
        return OutputIterator ( myti->begin(aPoint) );
      }
      OutputIterator outputIterator ( const Point &aPoint ) {…}

      ReverseOutputIterator routputIterator()
      {
        return ReverseOutputIterator ( myti->begin() );
      }
      ReverseOutputIterator routputIterator() {…}

      ReverseOutputIterator routputIterator ( const Point &aPoint )
      {
        return ReverseOutputIterator ( myti->begin(aPoint) );
      }
      ReverseOutputIterator routputIterator ( const Point &aPoint ) {…}

      ReverseIterator rbegin()
      {
        return ReverseIterator ( this->end() );
      }
      ReverseIterator rbegin() {…}

      ReverseIterator rbegin ( const Point &aPoint )
      {
        return ReverseIterator ( myti->rbegin(aPoint) );
      }
      ReverseIterator rbegin ( const Point &aPoint ) {…}

      ReverseIterator rend()
      {
        return ReverseIterator ( this->begin() );
      }
      ReverseIterator rend() {…}

      ConstReverseIterator rbegin() const
      {
        return ConstReverseIterator ( this->end() );
      }
      ConstReverseIterator rbegin() const {…}

      ConstReverseIterator rbegin ( const Point &aPoint ) const
      {
        return ConstReverseIterator ( myti->rbegin(aPoint) );
      }
      ConstReverseIterator rbegin ( const Point &aPoint ) const {…}

      ConstReverseIterator rend() const
      {
        return ConstReverseIterator ( this->begin() );
      }
      ConstReverseIterator rend() const {…}
 
      // /**
      //  * Circulator service.
      //  * @return a circulator
      //  */
      // Circulator c() const
      // {
      //   return Circulator ( this->begin(), this->begin(), this->end() );
      // }
 
      // /**
      //  * Circulator service.
      //  * @return a reverse circulator
      //  */
      // ReverseCirculator rc() const
      // {
      //   return ReverseCirculator ( this->c() );
      // }
 
  }; //end class TiledImageBidirectionalRangeFromPoint
  class TiledImageBidirectionalRangeFromPoint {…};
 
} // namespace DGtal

 
 
#endif // !defined TiledImageBidirectionalRangeFromPoint_h
 
#undef TiledImageBidirectionalRangeFromPoint_RECURSES
#endif // else defined(TiledImageBidirectionalRangeFromPoint_RECURSES)