DefaultImageRange.h

 
#pragma once
 
#if defined(DefaultImageRange_RECURSES)
#error Recursive header files inclusion detected in DefaultImageRange.h
#else // defined(DefaultImageRange_RECURSES)
#define DefaultImageRange_RECURSES
 
#if !defined DefaultImageRange_h
#define DefaultImageRange_h
 
// Inclusions
#include "DGtal/base/ConstIteratorAdapter.h"
#include "DGtal/kernel/domains/CDomain.h"
#include "DGtal/images/CTrivialImage.h"
#include "DGtal/images/SetValueIterator.h"
#include "boost/concept_check.hpp"
 
namespace DGtal 
{
 
 
  // class DefaultImageRange
 
  template <typename TImage>
  class DefaultImageRange
  {
 
 
    // ------------------------- inner types --------------------------------
  public: 
  
    BOOST_CONCEPT_ASSERT(( concepts::CTrivialImage<TImage> ));
    typedef typename TImage::Domain Domain; 
    typedef typename TImage::Point Point; 
    typedef typename TImage::Value Value; 
 
    BOOST_CONCEPT_ASSERT(( concepts::CDomain<Domain> )); 
    typedef ConstIteratorAdapter<typename Domain::ConstIterator,TImage,Value> ConstIterator; 
    typedef std::reverse_iterator<ConstIterator> ConstReverseIterator;
 
    typedef SetValueIterator<TImage> OutputIterator;
    typedef SetValueIterator<TImage, typename Domain::ConstReverseIterator> ReverseOutputIterator;
 
    // ------------------------- standard services --------------------------------
 
    DefaultImageRange( TImage& aImage )
      : myImagePtr(&aImage) {}
 
    DefaultImageRange( const DefaultImageRange & other )
      : myImagePtr(other.myImagePtr) {}
  
    DefaultImageRange& operator= ( const DefaultImageRange & other )
    {  
      if ( this != &other )
        {
          myImagePtr = other.myImagePtr;
        }
      return *this;
    }
 
    ~DefaultImageRange() {}
 
    bool isValid() const { return true; }
  
  
 
    // ------------------------- private data --------------------------------
  private: 
    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());
    }
 
    // ------------------------- iterator services (write-only) --------------------------------
  public: 
    OutputIterator outputIterator() const {
      Domain d = myImagePtr->domain(); 
      return OutputIterator( d.begin(), *myImagePtr );
    }
 
    OutputIterator outputIterator(const Point& aPoint) const {
      Domain d = myImagePtr->domain(); 
      return OutputIterator( d.begin(aPoint), *myImagePtr );
    }
 
    ReverseOutputIterator routputIterator() const {
      Domain d = myImagePtr->domain();
      return ReverseOutputIterator( d.rbegin(), *myImagePtr );
    }
 
    ReverseOutputIterator routputIterator(const Point& aPoint) const {
      Domain d = myImagePtr->domain();
      return ReverseOutputIterator( d.rbegin(aPoint), *myImagePtr );
    }
 
  }; //end class DefaultImageRange
 
} // namespace DGtal
 
 
 
#endif // !defined DefaultImageRange_h
 
#undef DefaultImageRange_RECURSES
#endif // else defined(DefaultImageRange_RECURSES)