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/base/ConstAlias.h"
#include "DGtal/kernel/domains/CDomain.h"
#include "DGtal/images/CTrivialConstImage.h"
#include "DGtal/images/SetValueIterator.h"
#include "boost/concept_check.hpp"
#include "boost/iterator/reverse_iterator.hpp"
 
namespace DGtal 
{
 
 
  // class DefaultConstImageRange
 
  template <typename TImage>
  class DefaultConstImageRange
  {
 
 
    // ------------------------- inner types --------------------------------
  public: 
  
    BOOST_CONCEPT_ASSERT(( concepts::CTrivialConstImage<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 boost::reverse_iterator<ConstIterator> ConstReverseIterator;
 
    // ------------------------- standard services --------------------------------
 
    DefaultConstImageRange( ConstAlias<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)