ImageCache.h

 
#pragma once
 
#if defined(ImageCache_RECURSES)
#error Recursive header files inclusion detected in ImageCache.h
#else // defined(ImageCache_RECURSES)
#define ImageCache_RECURSES
 
#if !defined ImageCache_h
#define ImageCache_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"
 
namespace DGtal
{   
 
// CACHE_READ_POLICY_LAST, CACHE_READ_POLICY_FIFO, CACHE_READ_POLICY_LRU, CACHE_READ_POLICY_NEIGHBORS   // read policies
// CACHE_WRITE_POLICY_WT, CACHE_WRITE_POLICY_WB                                                         // write policies
    
// Template class ImageCache
template <typename TImageContainer, typename TImageFactory, typename TReadPolicy, typename TWritePolicy>
class ImageCache
{
 
    // ----------------------- Types ------------------------------
 
public:
    typedef ImageCache<TImageContainer, TImageFactory, TReadPolicy, TWritePolicy> Self; 
    
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageFactory<TImageFactory> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageCacheReadPolicy<TReadPolicy> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageCacheWritePolicy<TWritePolicy> ));
 
    typedef TImageContainer ImageContainer;
    typedef typename ImageContainer::Domain Domain;
    typedef typename ImageContainer::Point Point;
    typedef typename ImageContainer::Value Value;
    
    typedef TImageFactory ImageFactory;
    
    typedef TReadPolicy ReadPolicy;
    typedef TWritePolicy WritePolicy;
 
    // ----------------------- Standard services ------------------------------
 
public:
  
    ImageCache(Alias<ImageFactory> anImageFactory, Alias<ReadPolicy> aReadPolicy, Alias<WritePolicy> aWritePolicy):
      myImageFactoryPtr(&anImageFactory), myReadPolicy(&aReadPolicy), myWritePolicy(&aWritePolicy)
    {
      myReadPolicy->clearCache();
      
      cacheMissRead = 0;
      cacheMissWrite = 0;
    }
    
    ~ImageCache()
    {
    }
    
private:
    
    ImageCache( const ImageCache & other );
        
    ImageCache & operator=( const ImageCache & other );
 
    // ----------------------- Interface --------------------------------------
public:
 
 
 
 
    
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const
    {
        return (myImageFactoryPtr->isValid());
    }
    
    bool read(const Point & aPoint, Value &aValue) const;
    
    ImageContainer * getPage(const Domain & aDomain) const;
 
    bool write(const Point & aPoint, const Value &aValue);
    
    void update(const Domain &aDomain);
    
    unsigned int getCacheMissRead()
    {
        return cacheMissRead;
    }
    
    unsigned int getCacheMissWrite()
    {
        return cacheMissWrite;
    }
    
    void incCacheMissRead()
    {
        cacheMissRead++;
    }
    
    void incCacheMissWrite()
    {
        cacheMissWrite++;
    }
    
    void clearCacheAndResetCacheMisses()
    {
      myReadPolicy->clearCache();
      
      cacheMissRead = 0;
      cacheMissWrite = 0;
    }
 
    // ------------------------- Protected Datas ------------------------------
private:
    //ImageCache() {}
    
    // ------------------------- Private Datas --------------------------------
protected:
 
    ImageFactory * myImageFactoryPtr;
    
    ReadPolicy * myReadPolicy;
    WritePolicy * myWritePolicy;
    
private:
    
    unsigned int cacheMissRead;
    unsigned int cacheMissWrite;
 
    // ------------------------- Internals ------------------------------------
private:
 
}; // end of class ImageCache
 
 
template <typename TImageContainer, typename TImageFactory, typename TReadPolicy, typename TWritePolicy>
std::ostream&
operator<< ( std::ostream & out, const ImageCache<TImageContainer, TImageFactory, TReadPolicy, TWritePolicy> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/images/ImageCachePolicies.h"
#include "DGtal/images/ImageCache.ih"
 
//                                                                           //
 
#endif // !defined ImageCache_h
 
#undef ImageCache_RECURSES
#endif // else defined(ImageCache_RECURSES)