TiledImage.h

 
#pragma once
 
#if defined(TiledImage_RECURSES)
#error Recursive header files inclusion detected in TiledImage.h
#else // defined(TiledImage_RECURSES)
#define TiledImage_RECURSES
 
#if !defined TiledImage_h
#define TiledImage_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/ConceptUtils.h"
#include "DGtal/images/CImage.h"
#include "DGtal/images/CImageFactory.h"
#include "DGtal/images/CImageCacheReadPolicy.h"
#include "DGtal/images/CImageCacheWritePolicy.h"
#include "DGtal/base/Alias.h"
 
#include "DGtal/images/ImageCache.h"
 
#include "DGtal/base/TiledImageBidirectionalConstRangeFromPoint.h"
#include "DGtal/base/TiledImageBidirectionalRangeFromPoint.h"
 
#include "boost/iterator/reverse_iterator.hpp"
 
namespace DGtal
{
  // Template class TiledImage
  template <typename TImageContainer, typename TImageFactory, typename TImageCacheReadPolicy, typename TImageCacheWritePolicy>
  class TiledImage
  {
 
    // ----------------------- Types ------------------------------
 
  public:
    typedef TiledImage<TImageContainer, TImageFactory, TImageCacheReadPolicy, TImageCacheWritePolicy> Self;
 
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageFactory<TImageFactory> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageCacheReadPolicy<TImageCacheReadPolicy> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageCacheWritePolicy<TImageCacheWritePolicy> ));
 
    typedef TImageContainer ImageContainer;
    typedef typename ImageContainer::Domain Domain;
    typedef typename ImageContainer::Point Point;
    typedef typename ImageContainer::Value Value;
 
    typedef typename ImageContainer::Difference Difference;
 
    typedef TImageFactory ImageFactory;
    typedef typename ImageFactory::OutputImage OutputImage;
 
    typedef TImageCacheReadPolicy ImageCacheReadPolicy;
    typedef TImageCacheWritePolicy ImageCacheWritePolicy;
    typedef ImageCache<OutputImage, ImageFactory, ImageCacheReadPolicy, ImageCacheWritePolicy > MyImageCache;
 
    // ----------------------- Standard services ------------------------------
 
  public:
 
    TiledImage(Alias<ImageFactory> anImageFactory,
               Alias<ImageCacheReadPolicy> aReadPolicy,
               Alias<ImageCacheWritePolicy> aWritePolicy,
               typename Domain::Integer N):
      myN(N), myImageFactory(&anImageFactory), myReadPolicy(&aReadPolicy), myWritePolicy(&aWritePolicy)
    {
      myImageCache = new MyImageCache(myImageFactory, myReadPolicy, myWritePolicy);
 
      m_lowerBound = myImageFactory->domain().lowerBound();
      m_upperBound = myImageFactory->domain().upperBound();
 
      for(typename DGtal::Dimension i=0; i<Domain::dimension; i++)
        mySize[i] = (m_upperBound[i]-m_lowerBound[i]+1)/myN;
    }
 
    ~TiledImage()
    {
      delete myImageCache;
    }
 
  private:
 
  public:
 
    TiledImage( const TiledImage &other )
    {
      myN =  other.myN;
      myImageFactory = other.myImageFactory;
      myReadPolicy = other.myReadPolicy;
      myWritePolicy = other.myWritePolicy;
 
      myImageCache = new MyImageCache(myImageFactory, myReadPolicy, myWritePolicy);
 
      m_lowerBound = myImageFactory->domain().lowerBound();
      m_upperBound = myImageFactory->domain().upperBound();
 
      for(typename DGtal::Dimension i=0; i<Domain::dimension; i++)
        mySize[i] = (m_upperBound[i]-m_lowerBound[i]+1)/myN;
    }
 
    TiledImage & operator=( const TiledImage & other )
    {
        if ( this != &other )
        {
          myN =  other.myN;
          myImageFactory = other.myImageFactory;
          myReadPolicy = other.myReadPolicy;
          myWritePolicy = other.myWritePolicy;
 
          myImageCache = new MyImageCache(myImageFactory, myReadPolicy, myWritePolicy);
 
          m_lowerBound = myImageFactory->domain().lowerBound();
          m_upperBound = myImageFactory->domain().upperBound();
 
          for(typename DGtal::Dimension i=0; i<Domain::dimension; i++)
            mySize[i] = (m_upperBound[i]-m_lowerBound[i]+1)/myN;
        }
 
        return *this;
    }
 
    // ----------------------- Interface --------------------------------------
  public:
 
 
    const Domain & domain() const
    {
      return myImageFactory->domain();
    }
 
    const Domain domainBlockCoords() const
    {
      Point lowerBoundCords, upperBoundCoords;
 
      for(typename DGtal::Dimension i=0; i<Domain::dimension; i++)
        {
          lowerBoundCords[i] = 0;
          upperBoundCoords[i] = myN;
 
          if (((m_upperBound[i]-m_lowerBound[i]+1) % myN) == 0)
            upperBoundCoords[i]--;
        }
 
      return Domain(lowerBoundCords, upperBoundCoords);
    }
 
 
    class TiledIterator
    {
 
      friend class TiledImage<ImageContainer, ImageFactory, ImageCacheReadPolicy, ImageCacheWritePolicy>;
 
    public:
      
      using iterator_category = std::bidirectional_iterator_tag;
      using value_type = Value;
      using difference_type = ptrdiff_t;
      using pointer = Value*;
      using reference = Value&;
      
      typedef typename ImageContainer::Range::/*Output*/Iterator TiledRangeIterator;
      typedef typename Domain::Iterator BlockCoordsIterator;
 
      //TiledIterator();
 
      TiledIterator ( BlockCoordsIterator aBlockCoordsIterator,
                      const TiledImage<ImageContainer, ImageFactory,
                      ImageCacheReadPolicy, ImageCacheWritePolicy> *aTiledImage ) :  myTiledImage ( aTiledImage ),
                                                                                     myBlockCoordsIterator ( aBlockCoordsIterator )
      {
        if ( myBlockCoordsIterator != myTiledImage->domainBlockCoords().end() )
          {
            myTile = myTiledImage->findTileFromBlockCoords( (*myBlockCoordsIterator) );
            myTiledRangeIterator = myTile->range().begin();
          }
      }
 
      TiledIterator ( BlockCoordsIterator aBlockCoordsIterator,
                      const Point& aPoint,
                      const TiledImage<ImageContainer, ImageFactory,
                      ImageCacheReadPolicy, ImageCacheWritePolicy> *aTiledImage ) :  myTiledImage ( aTiledImage ),
                                                                                     myBlockCoordsIterator ( aBlockCoordsIterator )
      {
        if ( myBlockCoordsIterator != myTiledImage->domainBlockCoords().end() )
          {
            myTile = myTiledImage->findTileFromBlockCoords( (*myBlockCoordsIterator) );
            myTiledRangeIterator = myTile->range().begin(aPoint);
          }
      }
 
      inline
      Value & operator*()
      {
        return (*myTiledRangeIterator);
      }
 
      inline
      bool operator== ( const TiledIterator &it ) const
      {
        return ( ( this->myBlockCoordsIterator == it.myBlockCoordsIterator ) && ( this->myTiledRangeIterator == it.myTiledRangeIterator ) );
      }
 
      inline
      bool operator!= ( const TiledIterator &it ) const
      {
        if ( myBlockCoordsIterator == myTiledImage->domainBlockCoords().end() )
          return false;
 
        return ( ( this->myBlockCoordsIterator != it.myBlockCoordsIterator ) || ( this->myTiledRangeIterator != it.myTiledRangeIterator ) );
      }
 
      inline
      void nextLexicographicOrder()
      {
        myTiledRangeIterator++;
 
        if ( myTiledRangeIterator != myTile->range().end() )
          return;
        else
          {
            myBlockCoordsIterator++;
 
            if ( myBlockCoordsIterator == myTiledImage->domainBlockCoords().end() )
              return;
 
            myTile = myTiledImage->findTileFromBlockCoords( (*myBlockCoordsIterator) );
            myTiledRangeIterator = myTile->range().begin();
          }
      }
 
      inline
      TiledIterator &operator++()
      {
        nextLexicographicOrder();
        return *this;
      }
 
      inline
      TiledIterator operator++ ( int )
      {
        TiledIterator tmp = *this;
        nextLexicographicOrder();
        return tmp;
      }
 
      inline
      void prevLexicographicOrder()
      {
        // -- IF we are at the end... (reverse, --)
        if ( myBlockCoordsIterator == myTiledImage->domainBlockCoords().end() )
          {
            myBlockCoordsIterator--;
 
            myTile = myTiledImage->findTileFromBlockCoords( (*myBlockCoordsIterator) );
 
            myTiledRangeIterator = myTile->range().end();
            myTiledRangeIterator--;
 
            return;
          }
        // -- IF we are at the end... (reverse, --)
 
        // ---
 
        if ( myTiledRangeIterator != myTile->range().begin() )
          {
            myTiledRangeIterator--;
            return;
          }
        else
          {
            if ( myBlockCoordsIterator == myTiledImage->domainBlockCoords().begin() )
              return;
 
            myBlockCoordsIterator--;
 
            myTile = myTiledImage->findTileFromBlockCoords( (*myBlockCoordsIterator) );
 
            myTiledRangeIterator = myTile->range().end();
            myTiledRangeIterator--;
          }
      }
 
      inline
      TiledIterator &operator--()
      {
        prevLexicographicOrder();
        return *this;
      }
 
      inline
      TiledIterator operator-- ( int )
      {
        TiledIterator tmp = *this;
        prevLexicographicOrder();
        return tmp;
      }
 
    private:
      const TiledImage *myTiledImage;
 
      ImageContainer * myTile;
 
      TiledRangeIterator myTiledRangeIterator;
 
      BlockCoordsIterator myBlockCoordsIterator;
    };
 
 
    typedef TiledIterator ConstIterator;
    typedef TiledIterator OutputIterator;
 
    typedef boost::reverse_iterator<TiledIterator> ReverseTiledIterator;
    typedef ReverseTiledIterator ConstReverseIterator;
    typedef ReverseTiledIterator ReverseOutputIterator;
 
 
    ConstIterator begin() const
    {
      return TiledIterator( this->domainBlockCoords().begin(), this );
    }
 
    OutputIterator begin()
    {
      return TiledIterator( this->domainBlockCoords().begin(), this );
    }
 
    ConstIterator begin(const Point& aPoint) const
    {
      Point coords = this->findBlockCoordsFromPoint(aPoint);
      return TiledIterator(  this->domainBlockCoords().begin(coords), aPoint, this );
    }
 
    OutputIterator begin(const Point& aPoint)
    {
      Point coords = this->findBlockCoordsFromPoint(aPoint);
      return TiledIterator(  this->domainBlockCoords().begin(coords), aPoint, this );
    }
 
    ConstIterator end() const
    {
      return TiledIterator( this->domainBlockCoords().end(), this );
    }
 
    OutputIterator end()
    {
      return TiledIterator( this->domainBlockCoords().end(), this );
    }
 
    ConstReverseIterator rbegin() const
    {
      return ReverseTiledIterator( end() );
    }
 
    ReverseOutputIterator rbegin()
    {
      return ReverseTiledIterator( end() );
    }
 
    ConstReverseIterator rbegin(const Point& aPoint) const
    {
      typename DGtal::Dimension i;
 
      Point point2;
      for(i=0; i<Domain::dimension; i++)
        point2[i]=(m_upperBound[i]-aPoint[i])+m_lowerBound[i];
 
      TiledIterator it( begin(point2) ); it++;
      return ReverseTiledIterator(it);
    }
 
    ReverseOutputIterator rbegin(const Point& aPoint)
    {
      typename DGtal::Dimension i;
 
      Point point2;
      for(i=0; i<Domain::dimension; i++)
        point2[i]=(m_upperBound[i]-aPoint[i])+m_lowerBound[i];
 
      TiledIterator it( begin(point2) ); it++;
      return ReverseTiledIterator(it);
    }
 
    ConstReverseIterator rend() const
    {
      return ReverseTiledIterator( begin() );
    }
 
    ConstReverseIterator rend()
    {
      return ReverseTiledIterator( begin() );
    }
 
    // ---
 
    OutputIterator outputIterator()
    {
      return OutputIterator( begin() );
    }
 
    OutputIterator outputIterator(const Point& aPoint)
    {
      return OutputIterator( begin(aPoint) );
    }
 
    ReverseOutputIterator routputIterator()
    {
      return ReverseOutputIterator( end() );
    }
 
    ReverseOutputIterator routputIterator(const Point &aPoint)
    {
      return ReverseOutputIterator( rbegin(aPoint) );
    }
 
 
    typedef TiledImageBidirectionalConstRangeFromPoint<TiledImage > ConstRange;
    typedef TiledImageBidirectionalRangeFromPoint<TiledImage > Range;
 
    ConstRange constRange() const
    {
      return ConstRange( this );
    }
 
    Range range()
    {
      return Range( this );
    }
 
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const
    {
      return (myImageFactory->isValid() && myImageCache->isValid());
    }
 
    const Domain findSubDomain(const Point & aPoint) const
    {
      ASSERT(myImageFactory->domain().isInside(aPoint));
 
      typename DGtal::Dimension i;
 
      Point low;
      for(i=0; i<Domain::dimension; i++)
        {
          low[i] = (aPoint[i]-m_lowerBound[i])/mySize[i];
        }
 
      Point dMin, dMax;
      for(i=0; i<Domain::dimension; i++)
        {
          dMin[i] = (low[i]*mySize[i])+m_lowerBound[i];
          dMax[i] = dMin[i] + (mySize[i]-1);
 
          if (dMax[i] > m_upperBound[i]) // last tile
            dMax[i] = m_upperBound[i];
        }
 
      Domain di(dMin, dMax);
      return di;
    }
 
    const Point findBlockCoordsFromPoint(const Point & aPoint) const
    {
      ASSERT(myImageFactory->domain().isInside(aPoint));
 
      typename DGtal::Dimension i;
 
      Point low;
      for(i=0; i<Domain::dimension; i++)
        {
          /*if ( (aPoint[i]-m_lowerBound[i]) < mySize[i] )
            low[i] = 0;
            else*/
          low[i] = (aPoint[i]-m_lowerBound[i])/mySize[i];
        }
 
      return low;
    }
 
    const Domain findSubDomainFromBlockCoords(const Point & aCoord) const
    {
      ASSERT(domainBlockCoords().isInside(aCoord));
 
      typename DGtal::Dimension i;
 
      Point dMin, dMax;
      for(i=0; i<Domain::dimension; i++)
        {
          dMin[i] = (aCoord[i]*mySize[i])+m_lowerBound[i];
          dMax[i] = dMin[i] + (mySize[i]-1);
 
          if (dMax[i] > m_upperBound[i]) // last tile
            dMax[i] = m_upperBound[i];
        }
 
      Domain di(dMin, dMax);
      return di;
    }
 
    ImageContainer * findTileFromBlockCoords(const Point & aCoord) const
    {
      ASSERT(domainBlockCoords().isInside(aCoord));
 
      Domain d = findSubDomainFromBlockCoords( aCoord );
      ImageContainer *tile = myImageCache->getPage(d);
      if (!tile)
        {
          myImageCache->incCacheMissRead();
          myImageCache->update(d);
          tile = myImageCache->getPage(d);
        }
 
      return tile;
    }
 
    Value operator()(const Point & aPoint) const
    {
      ASSERT(myImageFactory->domain().isInside(aPoint));
 
      typename OutputImage::Value aValue;
      bool res;
 
      res = myImageCache->read(aPoint, aValue);
 
      if (res)
        return aValue;
      else
        {
          myImageCache->incCacheMissRead();
          Domain d;
#ifdef DEBUG_VERBOSE
          trace.info()<<"+";
#endif 
          d = findSubDomain(aPoint);
 
          myImageCache->update(d);
 
          myImageCache->read(aPoint, aValue);
 
          return aValue;
        }
 
      // Unspecified behavior, returning the default constructed value.
      return aValue;
    }
 
    void setValue(const Point &aPoint, const Value &aValue)
    {
      ASSERT(myImageFactory->domain().isInside(aPoint));
 
      if (myImageCache->write(aPoint, aValue))
        return;
      else
        {
          myImageCache->incCacheMissWrite();
          myImageCache->update(findSubDomain(aPoint));
          myImageCache->write(aPoint, aValue);
        }
    }
 
    unsigned int getCacheMissRead()
    {
      return myImageCache->getCacheMissRead();
    }
 
    unsigned int getCacheMissWrite()
    {
      return myImageCache->getCacheMissWrite();
    }
 
    void clearCacheAndResetCacheMisses()
    {
      myImageCache->clearCacheAndResetCacheMisses();
    }
 
    // ------------------------- Private Datas --------------------------------
  protected:
 
    typename Domain::Integer myN;
 
    Point mySize;
 
    ImageFactory *myImageFactory;
 
    MyImageCache *myImageCache;
 
    Point m_lowerBound, m_upperBound;
 
    TImageCacheReadPolicy *myReadPolicy;
 
    TImageCacheWritePolicy *myWritePolicy;
 
    // ------------------------- Internals ------------------------------------
 
  }; // end of class TiledImage
 
 
  template <typename TImageContainer, typename TImageFactory, typename TImageCacheReadPolicy, typename TImageCacheWritePolicy>
  std::ostream&
  operator<< ( std::ostream & out, const TiledImage<TImageContainer, TImageFactory, TImageCacheReadPolicy, TImageCacheWritePolicy> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/images/TiledImage.ih"
 
//                                                                           //
 
#endif // !defined TiledImage_h
 
#undef TiledImage_RECURSES
#endif // else defined(TiledImage_RECURSES)