ArrayImageAdapter.h

 
#pragma once
 
#if defined(ArrayImageAdapter_RECURSES)
#error Recursive header files inclusion detected in ArrayImageAdapter.h
#else // defined(ArrayImageAdapter_RECURSES)
#define ArrayImageAdapter_RECURSES
 
#if !defined ArrayImageAdapter_h
#define ArrayImageAdapter_h
 
// Inclusions
#include <boost/concept/assert.hpp>
#include <boost/iterator/iterator_concepts.hpp>
#include <iterator>
#include <type_traits>
 
#include <DGtal/base/Common.h>
#include <DGtal/images/CConstImage.h>
#include <DGtal/images/ArrayImageIterator.h>
#include <DGtal/base/IteratorCompletion.h>
#include <DGtal/kernel/domains/Linearizer.h>
 
namespace DGtal
{
 
 
  template <
    typename TArrayIterator,
    typename TDomain
  >
  class ArrayImageAdapter;
 
 
  template <
    typename TArrayIterator,
    typename TSpace
  >
  class ArrayImageAdapter< TArrayIterator, HyperRectDomain<TSpace> >
      : public IteratorCompletion< ArrayImageAdapter< TArrayIterator, HyperRectDomain<TSpace> > >
    {
 
    // Checks Random-access iterator concept on TArrayIterator
    BOOST_CONCEPT_ASSERT( (boost_concepts::RandomAccessTraversalConcept<TArrayIterator>) );
 
    public:
      // Aliases
      using Self = ArrayImageAdapter<TArrayIterator, HyperRectDomain<TSpace> >;           
      using ArrayIterator   = TArrayIterator;                                             
      using Value           = typename std::iterator_traits<ArrayIterator>::value_type;   
      using Reference       = typename std::iterator_traits<ArrayIterator>::reference;    
      using ConstReference  = const Reference;                                            
 
      // DGtal aliases and constant
      using Domain    = HyperRectDomain<TSpace>;      
      using Point     = typename Domain::Point;       
      using Dimension = typename Domain::Dimension;   
      using Size      = typename Domain::Size;        
      using Vector    = typename Domain::Vector;      
      using Vertex    = Point;                        
      using Integer   = typename Domain::Integer;     
      BOOST_STATIC_CONSTANT( Dimension, dimension = Domain::dimension );  
 
      using Linearizer = DGtal::Linearizer<Domain, ColMajorStorage>; 
 
      // Iterators & Ranges
      template <class> friend class ArrayImageIterator;
      using Iterator      = typename IteratorCompletionTraits<Self>::Iterator;      
      using ConstIterator = typename IteratorCompletionTraits<Self>::ConstIterator; 
 
      ArrayImageAdapter()
        : myArrayIterator{nullptr}
        , myFullDomain{}
        , myViewDomain{}
        {}
 
      ArrayImageAdapter( ArrayIterator anArrayIterator, Domain const& aFullDomain, Domain const& aViewDomain )
          : myArrayIterator(anArrayIterator)
          , myFullDomain{ aFullDomain }
          , myViewDomain{ aViewDomain }
        {
          ASSERT_MSG(
                 aFullDomain.lowerBound().isLower( aViewDomain.lowerBound() )
              && aFullDomain.upperBound().isUpper( aViewDomain.upperBound() ),
              "The viewable domain must be included into the full domain."
          );
        }
 
      ArrayImageAdapter( ArrayIterator anArrayIterator, Domain const& aFullDomain )
          : ArrayImageAdapter( anArrayIterator, aFullDomain, aFullDomain )
        {
        }
 
      ArrayImageAdapter( Self const& other, Domain const& aViewDomain )
          : ArrayImageAdapter( other.myArrayIterator, other.myFullDomain, aViewDomain )
        {}
 
      inline
      Domain domain() const
        {
          return myViewDomain;
        }
 
      inline
      Domain fullDomain() const
        {
          return myFullDomain;
        }
 
      inline
      Value getValue( Point const& aPoint ) const
        {
          ASSERT_MSG(
              myFullDomain.isInside(aPoint),
              "The point is outside the full domain."
          );
 
          return myArrayIterator[ Linearizer::getIndex(aPoint, myFullDomain) ];
        }
 
      inline
      void setValue( Point const& aPoint, Value aValue )
        {
          ASSERT_MSG(
              myFullDomain.isInside(aPoint),
              "The point is outside the full domain."
          );
 
          myArrayIterator[ Linearizer::getIndex(aPoint, myFullDomain) ] = aValue;
        }
 
      inline
      Value operator() ( Point const& aPoint ) const
        {
          return getValue(aPoint);
        }
 
      inline
      Iterator begin()
        {
          return Iterator{ this, myFullDomain, myViewDomain };
        }
 
      inline
      ConstIterator begin() const
        {
          return ConstIterator{ this, myFullDomain, myViewDomain };
        }
 
      inline
      ConstIterator cbegin() const
        {
          return ConstIterator{ this, myFullDomain, myViewDomain };
        }
 
      inline
      Iterator end()
        {
          return Iterator{ this, myFullDomain, myViewDomain, true };
        }
 
      inline
      ConstIterator end() const
        {
          return ConstIterator{ this, myFullDomain, myViewDomain, true };
        }
 
      inline
      ConstIterator cend() const
        {
          return ConstIterator{ this, myFullDomain, myViewDomain, true };
        }
 
 
    public: // Should be private since ArrayImageIterator is a friend but g++ 4.9.1 don't care ... (no prob with clang++ 3.5.0)
 
      inline
      Reference dereference( Point const& /* aPoint */, typename Point::Coordinate aFullIndex )
        {
          ASSERT_MSG(
              aFullIndex >= 0 && static_cast<typename Domain::Size>(aFullIndex) < myFullDomain.size(),
              "linearized index out of bounds !"
          );
          return myArrayIterator[aFullIndex];
        }
 
      inline
      ConstReference dereference( Point const& /* aPoint */, typename Point::Coordinate aFullIndex ) const
        {
          ASSERT_MSG(
              aFullIndex >= 0 && static_cast<typename Domain::Size>(aFullIndex) < myFullDomain.size(),
              "linearized index out of bounds !"
          );
          return myArrayIterator[aFullIndex];
        }
 
    // ----------------------- Interface --------------------------------------
    public:
      void selfDisplay ( std::ostream & out ) const
        {
          out << "[ArrayImageAdapter] with full domain " << myFullDomain << " and viewable domain " << myViewDomain;
        }
 
      bool isValid() const
        {
          return true;
        }
 
    // ------------------------- Private Datas --------------------------------
    private:
      ArrayIterator myArrayIterator; 
      Domain myFullDomain;  
      Domain myViewDomain;  
 
    }; // end of class ArrayImageAdapter
 
 
  template <
    typename TArrayIterator,
    typename TDomain
  >
  class IteratorCompletionTraits< ArrayImageAdapter<TArrayIterator, TDomain> >
    {
    public:
      using Self = ArrayImageAdapter<TArrayIterator, TDomain>;  
      using Iterator = ArrayImageIterator<Self>; 
      using ConstIterator = ArrayImageIterator<const Self>; 
 
      class DistanceFunctor
        {
        public:
          using Domain = typename Self::Domain;         
          using Point = typename Self::Point;           
          using Difference = typename Self::Difference; 
 
          DistanceFunctor( Self const* anImage )
            : myDomain( anImage->domain() )
            {}
 
          Difference operator() ( Point const& aPoint ) const
            {
              ASSERT_MSG(
                  myDomain.isInside(aPoint),
                  "The point is outside the domain !"
              );
              return Linearizer<Domain, ColMajorStorage>::getIndex( aPoint, myDomain );
            }
 
        private:
          Domain myDomain; 
        };
 
    }; // end of specialized class IteratorCompletionTraits
 
 
  template <
    typename TArrayIterator,
    typename TDomain
  >
  std::ostream&
  operator<< ( std::ostream & out, const ArrayImageAdapter<TArrayIterator, TDomain> & object )
    {
      object.selfDisplay( out );
      return out;
    }
 
 
  // ------------------ ArrayImageAdapter construction helpers ----------------
 
  template <
    typename TArrayIterator,
    typename TDomain
  >
  ArrayImageAdapter< TArrayIterator, TDomain >
  makeArrayImageAdapterFromIterator( TArrayIterator anArrayIterator, TDomain const& aFullDomain, TDomain const& aViewDomain )
    {
      return { anArrayIterator, aFullDomain, aViewDomain };
    }
 
  template <
    typename TArrayIterator,
    typename TDomain
  >
  ArrayImageAdapter< TArrayIterator, TDomain >
  makeArrayImageAdapterFromIterator( TArrayIterator anArrayIterator, TDomain const& aFullDomain )
    {
      return { anArrayIterator, aFullDomain, aFullDomain };
    }
 
  template <
    typename TImage,
    typename TDomain = typename TImage::Domain
  >
  // We use decltype on begin() iterator because it returns the constant iterator
  //  if the image is constant while ::Iterator typedef returns the mutable iterator.
  ArrayImageAdapter< decltype( ((TImage*)nullptr)->begin() ), TDomain >
  makeArrayImageAdapterFromImage( TImage & anImage, TDomain const& aViewDomain )
    {
      // Remove constness because CConstImage requires assignability.
      BOOST_CONCEPT_ASSERT( (DGtal::concepts::CConstImage< typename std::remove_const<TImage>::type >) );
 
      return { anImage.begin(), anImage.domain(), aViewDomain };
    }
 
  template <
    typename TImage,
    typename TDomain = typename TImage::Domain
  >
  // We use decltype on begin() iterator because it returns the constant iterator
  //  if the image is constant while ::Iterator typedef returns the mutable iterator.
  ArrayImageAdapter< decltype( ((TImage*)nullptr)->begin() ), TDomain >
  makeArrayImageAdapterFromImage( TImage & anImage )
    {
      // Remove constness because CConstImage requires assignability.
      BOOST_CONCEPT_ASSERT( (DGtal::concepts::CConstImage< typename std::remove_const<TImage>::type >) );
 
      return { anImage.begin(), anImage.domain(), anImage.domain() };
    }
 
} // namespace DGtal
 
//                                                                           //
 
#endif // !defined ArrayImageAdapter_h
 
#undef ArrayImageAdapter_RECURSES
#endif // else defined(ArrayImageAdapter_RECURSES)