ImageCache.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _HUGINAPP_IMAGECACHE_H
#define _HUGINAPP_IMAGECACHE_H

#include <hugin_shared.h>
#include "hugin_config.h"
#include <map>
#include <vector>
#include <memory>
#include <functional>
#include <vigra/stdimage.hxx>
#include <vigra/imageinfo.hxx>
#include <hugin_utils/utils.h>
#include <appbase/ProgressDisplay.h>

#define HUGIN_IMGCACHE_MAPPING_INTEGER        0l
#define HUGIN_IMGCACHE_MAPPING_FLOAT          1l


namespace HuginBase {
    
class IMPEX ImageCache
{

    public:
        typedef std::shared_ptr<vigra::BRGBImage> ImageCacheRGB8Ptr;
        typedef std::shared_ptr<vigra::UInt16RGBImage> ImageCacheRGB16Ptr;
        typedef std::shared_ptr<vigra::FRGBImage> ImageCacheRGBFloatPtr;
        typedef std::shared_ptr<vigra::BImage> ImageCache8Ptr;
        typedef std::shared_ptr<vigra::ImageImportInfo::ICCProfile> ImageCacheICCProfile;

        struct IMPEX Entry
        {
            ImageCacheRGB8Ptr image8;
            ImageCacheRGB16Ptr image16;
            ImageCacheRGBFloatPtr imageFloat;
            ImageCache8Ptr mask;
            ImageCacheICCProfile iccProfile;

            std::string origType;
            int lastAccess;

            public:
                Entry()
                  : image8(ImageCacheRGB8Ptr(new vigra::BRGBImage)),
                    image16(ImageCacheRGB16Ptr(new vigra::UInt16RGBImage)),
                    imageFloat(ImageCacheRGBFloatPtr(new vigra::FRGBImage)),
                    mask(ImageCache8Ptr(new vigra::BImage)),
                    iccProfile(ImageCacheICCProfile(new vigra::ImageImportInfo::ICCProfile)),
                    lastAccess(0)
                {
                      DEBUG_TRACE("Constructing an empty ImageCache::Entry");
                };

                Entry(ImageCacheRGB8Ptr & img, 
                      ImageCacheRGB16Ptr & img16,
                      ImageCacheRGBFloatPtr & imgFloat,
                      ImageCache8Ptr & imgMask,
                      ImageCacheICCProfile & ICCProfile,
                      const std::string & typ)
                  : image8(img), image16(img16), imageFloat(imgFloat), mask(imgMask),
                    iccProfile(ICCProfile), origType(typ), lastAccess(0)
                { 
                        DEBUG_TRACE("Constructing ImageCache::Entry");
                };

                ~Entry()
                {
                    DEBUG_TRACE("Deleting ImageCacheEntry");
                };

                ImageCacheRGB8Ptr get8BitImage();
        };

        typedef std::shared_ptr<Entry> EntryPtr;
        
        class Request
        {
            public:
                Request(std::string filename, bool request_small)
                    :m_filename(filename), m_isSmall(request_small)
                    {};
                std::vector <std::function<void(EntryPtr, std::string, bool)>> ready;
                bool getIsSmall() const
                    {return m_isSmall;};
                const std::string & getFilename() const
                    {return m_filename;};
            protected:
                std::string m_filename;
                bool m_isSmall;
        };
        
        typedef std::shared_ptr<Request> RequestPtr;

    private:
        // ctor. private, nobody execpt us can create an instance.
        ImageCache()
            : asyncLoadCompleteSignal(0), upperBound(100*1024*1024ull),
              m_progress(NULL), m_accessCounter(0)
        {};
        
    public:
        virtual ~ImageCache()
        {
                images.clear();
                instance = NULL;
        }

        static ImageCache & getInstance();
        
    private:
        static ImageCache* instance;

        
    public:
        EntryPtr getImage(const std::string & filename);
        
        EntryPtr getImageIfAvailable(const std::string & filename);

        EntryPtr getSmallImage(const std::string & filename);
        
        EntryPtr getSmallImageIfAvailable(const std::string & filename);
         
        RequestPtr requestAsyncImage(const std::string & filename);
        
        RequestPtr requestAsyncSmallImage(const std::string & filename);

        void removeImage(const std::string & filename);

        void flush();

        void softFlush();
                void SetUpperLimit(const unsigned long long newUpperLimit) { upperBound=newUpperLimit; };
        
        void (*asyncLoadCompleteSignal)(RequestPtr, EntryPtr);
        
        void postEvent(RequestPtr request, EntryPtr entry);
        
        void removeRequest(RequestPtr request);

    private:
        unsigned long long upperBound;

        template <class SrcPixelType,
                  class DestIterator, class DestAccessor>
        static void importAndConvertImage(const vigra::ImageImportInfo& info,
                                   vigra::pair<DestIterator, DestAccessor> dest,
                                   const std::string& type);
        
    //    template <class SrcPixelType,
    //              class DestIterator, class DestAccessor>
    //    void importAndConvertGrayImage(const ImageImportInfo& info,
    //                                   vigra::pair<DestIterator, DestAccessor> dest,
    //                                   wxString type);
        
    //    template <class SrcPixelType,
    //              class DestIterator, class DestAccessor>
    //    void importAndConvertGrayAlphaImage(const ImageImportInfo & info,
    //                                        vigra::pair<DestIterator, DestAccessor> dest,
    //                                        wxString type);
        
        template <class SrcPixelType,
                  class DestIterator, class DestAccessor,
                  class MaskIterator, class MaskAccessor>
        static void importAndConvertAlphaImage(const vigra::ImageImportInfo & info,
                                        vigra::pair<DestIterator, DestAccessor> dest,
                                        vigra::pair<MaskIterator, MaskAccessor> mask,
                                        const std::string & type);
        
        
    public:
        void setProgressDisplay(AppBase::ProgressDisplay* disp)
            { m_progress = disp; }
        
        void clearProgressDisplay(AppBase::ProgressDisplay* disp)
            { m_progress = NULL; }
        
        
    private:
        std::map<std::string, EntryPtr> images;

        // our progress display
        AppBase::ProgressDisplay* m_progress;

        int m_accessCounter;
        
        // Requests for full size images that need loading
        std::map<std::string, RequestPtr> m_requests;
        
        // Requests for small images that need generating.
        std::map<std::string, RequestPtr> m_smallRequests;
        
        void spawnAsyncThread();
        
        static void loadSafely(RequestPtr request, EntryPtr large = EntryPtr());
        
        static EntryPtr loadImageSafely(const std::string & filename);
        
        static EntryPtr loadSmallImageSafely(EntryPtr entry);
        
    public:
    //    const vigra::BImage & getPyramidImage(const std::string& filename,
    //                                          int level);

    private:
        // key for your pyramid map.
        struct PyramidKey
        {
            std::string filename;
            int level;
            
            public:
                PyramidKey(const std::string& str, int lv)
                  : filename(str), level(lv)
                {};
            
                std::string toString();
        };
        
        std::map<std::string, vigra::BImage *> pyrImages;
};


} //namespace
#endif // _IMAGECACHE_H