ImageCachePolicies.h

 
#pragma once
 
#if defined(ImageCachePolicies_RECURSES)
#error Recursive header files inclusion detected in ImageCachePolicies.h
#else // defined(ImageCachePolicies_RECURSES)
#define ImageCachePolicies_RECURSES
 
#if !defined ImageCachePolicies_h
#define ImageCachePolicies_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/base/Alias.h"
 
#include "DGtal/images/ImageCache.h"
 
namespace DGtal
{
 
// Template class ImageCacheReadPolicyLAST
template <typename TImageContainer, typename TImageFactory>
class ImageCacheReadPolicyLAST
{
public:
  
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageFactory<TImageFactory> ));    
    
    typedef TImageFactory ImageFactory;
    
    typedef TImageContainer ImageContainer;
    typedef typename TImageContainer::Domain Domain;
    typedef typename TImageContainer::Point Point;
    typedef typename TImageContainer::Value Value;
    
    ImageCacheReadPolicyLAST(Alias<ImageFactory> anImageFactory):
      myCacheImagesPtr(NULL),  myImageFactory(&anImageFactory)
    {
    }
 
    ~ImageCacheReadPolicyLAST() {}
    
private:
    
    ImageCacheReadPolicyLAST( const ImageCacheReadPolicyLAST & other );
    
    ImageCacheReadPolicyLAST & operator=( const ImageCacheReadPolicyLAST & other );
    
public:
    
    ImageContainer * getPage(const Point & aPoint);
    
    ImageContainer * getPage(const Domain & aDomain);
    
    ImageContainer * getPageToDetach();
    
    void updateCache(const Domain &aDomain);
    
    void clearCache();
    
protected:
    
    ImageContainer * myCacheImagesPtr;
    
    ImageFactory * myImageFactory;
    
}; // end of class ImageCacheReadPolicyLAST
 
// Template class ImageCacheReadPolicyFIFO
template <typename TImageContainer, typename TImageFactory>
class ImageCacheReadPolicyFIFO
{
public:
  
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageFactory<TImageFactory> ));    
    
    typedef TImageFactory ImageFactory;
    
    typedef TImageContainer ImageContainer;
    typedef typename TImageContainer::Domain Domain;
    typedef typename TImageContainer::Point Point;
    typedef typename TImageContainer::Value Value;
    
    ImageCacheReadPolicyFIFO(Alias<ImageFactory> anImageFactory, int aFIFOSizeMax=10):
       myFIFOSizeMax(aFIFOSizeMax), myImageFactory(&anImageFactory)
    {
    }
 
    ~ImageCacheReadPolicyFIFO() {}
    
private:
    
    ImageCacheReadPolicyFIFO( const ImageCacheReadPolicyFIFO & other );
    
    ImageCacheReadPolicyFIFO & operator=( const ImageCacheReadPolicyFIFO & other );
    
public:
    
    ImageContainer * getPage(const Point & aPoint);
    
    ImageContainer * getPage(const Domain & aDomain);
    
    ImageContainer * getPageToDetach();
    
    void updateCache(const Domain &aDomain);
    
    void clearCache();
    
protected:
    
    std::deque <ImageContainer *> myFIFOCacheImages;
    
    unsigned int myFIFOSizeMax;
    
    ImageFactory * myImageFactory;
    
}; // end of class ImageCacheReadPolicyFIFO
 
// Template class ImageCacheWritePolicyWT
template <typename TImageContainer, typename TImageFactory>
class ImageCacheWritePolicyWT
{
public:
  
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageFactory<TImageFactory> ));
  
    typedef TImageFactory ImageFactory;
    
    typedef TImageContainer ImageContainer;
    typedef typename TImageContainer::Domain Domain;
    typedef typename TImageContainer::Point Point;
    typedef typename TImageContainer::Value Value;
    
    ImageCacheWritePolicyWT(Alias<ImageFactory> anImageFactory):
      myImageFactory(&anImageFactory)
    {
    }
 
    ~ImageCacheWritePolicyWT() {}
    
private:
    
    ImageCacheWritePolicyWT( const ImageCacheWritePolicyWT & other );
    
    ImageCacheWritePolicyWT & operator=( const ImageCacheWritePolicyWT & other );
    
public:
    
    void writeInPage(ImageContainer * anImageContainer, const Point & aPoint, const Value &aValue);
    
    void flushPage(ImageContainer * anImageContainer);
    
protected:
    
    ImageFactory * myImageFactory;
    
}; // end of class ImageCacheWritePolicyWT
 
// Template class ImageCacheWritePolicyWB
template <typename TImageContainer, typename TImageFactory>
class ImageCacheWritePolicyWB
{
public:
  
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageFactory<TImageFactory> ));
  
    typedef TImageFactory ImageFactory;
    
    typedef TImageContainer ImageContainer;
    typedef typename TImageContainer::Domain Domain;
    typedef typename TImageContainer::Point Point;
    typedef typename TImageContainer::Value Value;
    
    ImageCacheWritePolicyWB(Alias<ImageFactory> anImageFactory):
      myImageFactory(&anImageFactory)
    {
    }
 
    ~ImageCacheWritePolicyWB() {}
    
private:
    
    ImageCacheWritePolicyWB( const ImageCacheWritePolicyWB & other );
    
    ImageCacheWritePolicyWB & operator=( const ImageCacheWritePolicyWB & other );
    
public:
    
    void writeInPage(ImageContainer * anImageContainer, const Point & aPoint, const Value &aValue);
    
    void flushPage(ImageContainer * anImageContainer);
    
protected:
    
    ImageFactory * myImageFactory;
    
}; // end of class ImageCacheWritePolicyWB
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/images/ImageCachePolicies.ih"
 
//                                                                           //
 
#endif // !defined ImageCachePolicies_h
 
#undef ImageCachePolicies_RECURSES
#endif // else defined(ImageCachePolicies_RECURSES)