creaImageIOMultiThreadImageReader.h

Go to the documentation of this file.

#ifndef __creaImageIOThreadedImageReader_h_INCLUDED__
#define __creaImageIOThreadedImageReader_h_INCLUDED__

#include <creaImageIOSystem.h>
#include <creaImageIOImageReader.h>
#include <creaImageIOIndexedHeap.h>
#include <map>
#include <deque>
#include <wx/thread.h>
#include <queue>

namespace creaImageIO
{
  //=====================================================================
  class ThreadedImageReader;
  class MultiThreadImageReader;
  //=====================================================================
  
  //=====================================================================
  class CREAIMAGEIO_EXPORT MultiThreadImageReaderUser
  {
  public:
    friend class ThreadedImageReader;
    friend class MultiThreadImageReader;

    MultiThreadImageReaderUser() {}
    virtual ~MultiThreadImageReaderUser() {}

    typedef enum 
      {
        ThreadedReaderStarted,
        ThreadedReaderStopped,
        ImageLoaded,
        ImageUnloaded,
        Error
      }
      EventType;
    virtual void OnMultiThreadImageReaderEvent( const std::string& filename,
                                                EventType type,
                                                vtkImageData* image) 
    {}
    inline void MultiThreadImageReaderEventLock() 
    { mMultiThreadImageReaderUserMutex.Lock(); }
    inline void MultiThreadImageReaderEventUnlock() 
    { mMultiThreadImageReaderUserMutex.Unlock(); }
    inline wxMutex& GetMultiThreadImageReaderUserMutex() 
    { return mMultiThreadImageReaderUserMutex; }
  private:
    void MultiThreadImageReaderSendEvent( const std::string& filename,
                                          EventType type,
                                          vtkImageData* image);
    wxMutex mMultiThreadImageReaderUserMutex;
  };
  //=====================================================================

  //=====================================================================

  class MultiThreadImageReader : public MultiThreadImageReaderUser
  {
  public:
    friend class ThreadedImageReader;

    MultiThreadImageReader(int number_of_threads = 1);
    ~MultiThreadImageReader();

    bool Start();
    void Stop();

    void Request( MultiThreadImageReaderUser* user,
                  const std::string& filename, 
                  int priority );
    
    vtkImageData* GetImage(const std::string& filename);

    int GetMaximalPriority(); 
    
    void OnMultiThreadImageReaderEvent( const std::string& filename,
                                        EventType type,
                                        vtkImageData* image);
    
  protected:
    int GetMaximalPriorityWithoutLocking();
    class ImageToLoad
    {
    public:
      ImageToLoad( MultiThreadImageReaderUser* user,
                   const std::string& filename, 
                   int prio=0) 
        : mUser(user),
          mFilename(filename), 
          mPriority(prio), 
          mIndex(-1), 
          mUnloadIndex(-1), 
          mImage(0)
      {}
      ~ImageToLoad()
      {
        if (mImage>0) 
          {
            //      std::cout << "Refs = "<<mImage->GetReferenceCount()<<std::endl;
            mImage->Delete();
          }
      }
      MultiThreadImageReaderUser* GetUser() const { return mUser; }
      void SetUser( MultiThreadImageReaderUser* u ) { mUser = u; }
      const std::string& GetFilename() const { return mFilename; }
      int GetPriority() const { return mPriority; }
      void SetPriority(int p) { mPriority=p; }
      int& Index() { return mIndex; }
      int& UnloadIndex() { return mUnloadIndex; }
      vtkImageData* GetImage() const { return mImage; }
      void SetImage( vtkImageData* i ) { mImage=i; }
    private:
      MultiThreadImageReaderUser* mUser;
      std::string mFilename;
      int mPriority;
      int mIndex;
      int mUnloadIndex;
      vtkImageData* mImage;
    };
    // 

    typedef ImageToLoad* ImageToLoadPtr;

    struct ImageToLoadPtrPriorityComparator
    {
      bool operator() (ImageToLoadPtr const & a, ImageToLoadPtr const & b)
        const 
      {
        return ( a->GetPriority() > b->GetPriority() );
      }
    };
    struct ImageToLoadPtrInversePriorityComparator
    {
      bool operator() (ImageToLoadPtr const & a, ImageToLoadPtr const & b)
        const 
      {
        return ( a->GetPriority() < b->GetPriority() );
      }
    };


    struct ImageToLoadPtrFilenameComparator
    {
      bool operator() (ImageToLoadPtr const & a, ImageToLoadPtr const & b)
        const 
      {
        return ( a->GetFilename() < b->GetFilename() );
      }
    };

    struct ImageToLoadPtrIndexer
    {
      int& operator()(ImageToLoadPtr & t) const { return t->Index(); }
    };
    struct ImageToUnloadPtrIndexer
    {
      int& operator()(ImageToLoadPtr & t) const { return t->UnloadIndex(); }
    };

    void SignalImageRead(ImageToLoadPtr p, bool purge);
  
    typedef std::map<ImageToLoadPtr,vtkImageData*,
                     ImageToLoadPtrFilenameComparator> ImageMapType;
    ImageMapType mImages;
    ImageToLoadPtrPriorityComparator mComparator;
    ImageToLoadPtrIndexer mIndexer;
    IndexedHeap<ImageToLoadPtr,
                ImageToLoadPtrPriorityComparator,
                ImageToLoadPtrIndexer> mQueue;

    typedef std::vector<ThreadedImageReader*> ThreadedImageReaderListType;
    ThreadedImageReaderListType mThreadedImageReaderList;
    int mNumberOfThreadedReadersRunning;
    //  wxMutex mMutex;

    std::string mRequestedFilename;
    vtkImageData* mRequestedImage;

    ImageReader* mReader;

    IndexedHeap<ImageToLoadPtr,
                ImageToLoadPtrInversePriorityComparator,
                ImageToUnloadPtrIndexer> mUnloadQueue;

    void UpdateUnloadPriority(ImageToLoadPtr p, int priority);
    long mTotalMem;
    long mTotalMemMax;


  }; // class MultiThreadImageReader
  //=====================================================================



} // namespace creaImageIO



#endif // #ifndef __creaImageIOThreadedImageReader_h_INCLUDED__

---