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 Data ------------------------------
private:
    //ImageCache() {}
 
    // ------------------------- Private Data --------------------------------
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)