DefaultConstImageRange.h

#pragma once

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

#define DefaultConstImageRange_RECURSES

#if !defined DefaultConstImageRange_h

#define DefaultConstImageRange_h

// Inclusions
#include "DGtal/base/ConstIteratorAdapter.h"
#include "DGtal/kernel/domains/CDomain.h"
#include "DGtal/images/CTrivialConstImage.h"
#include "DGtal/images/SetValueIterator.h"
#include "boost/concept_check.hpp"

namespace DGtal 
{


  // class DefaultConstImageRange

  template <typename TImage>
  class DefaultConstImageRange
  {


    // ------------------------- inner types --------------------------------
  public: 
  
    BOOST_CONCEPT_ASSERT(( CTrivialConstImage<TImage> ));
    typedef typename TImage::Domain Domain; 
    typedef typename TImage::Point Point; 
    typedef typename TImage::Value Value; 

    BOOST_CONCEPT_ASSERT(( CDomain<Domain> )); 
    typedef ConstIteratorAdapter<typename Domain::ConstIterator,TImage,Value> ConstIterator; 
    typedef std::reverse_iterator<ConstIterator> ConstReverseIterator;

    // ------------------------- standard services --------------------------------

    DefaultConstImageRange( const TImage& aImage )
      : myImagePtr(&aImage) {}

    DefaultConstImageRange( const DefaultConstImageRange & other )
      : myImagePtr(other.myImagePtr) {}
  
    DefaultConstImageRange& operator= ( const DefaultConstImageRange & other )
    {  
      if ( this != &other )
        {
          myImagePtr = other.myImagePtr;
        }
      return *this;
    }

    ~DefaultConstImageRange() {}

    bool isValid() const { return true; }
  
  

    // ------------------------- private data --------------------------------
  private: 
    const TImage* myImagePtr; 

    // ------------------------- iterator services (read-only) --------------------------------
  public:

    ConstIterator begin() const {
      Domain d = myImagePtr->domain(); 
      return ConstIterator( d.begin(), *myImagePtr );
    }

    ConstIterator begin(const Point& aPoint) const {
      Domain d = myImagePtr->domain(); 
      return ConstIterator( d.begin(aPoint), *myImagePtr );
    }

    ConstIterator end() const {
      Domain d = myImagePtr->domain(); 
      return ConstIterator( d.end(), *myImagePtr );
    }

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

    ConstReverseIterator rbegin(const Point& aPoint) const {
      Domain d = myImagePtr->domain(); 
      typename Domain::ConstIterator itOnPts = d.begin(aPoint); 
      if ( itOnPts != d.end() ) ++itOnPts; 
      ConstIterator itOnVals( itOnPts, *myImagePtr );
      return ConstReverseIterator( itOnVals );
    }

    ConstReverseIterator rend() const {
      return ConstReverseIterator(this->begin());
    }


  }; //end class DefaultConstImageRange

} // namespace DGtal



#endif // !defined DefaultConstImageRange_h

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