creaImageIOQMultiThreadImageReader.h

Go to the documentation of this file.

/*
# ---------------------------------------------------------------------
#
# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image 
#                        pour la Santé)
# Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
# Previous Authors : Laurent Guigues, Jean-Pierre Roux
# CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
#
#  This software is governed by the CeCILL-B license under French law and 
#  abiding by the rules of distribution of free software. You can  use, 
#  modify and/ or redistribute the software under the terms of the CeCILL-B 
#  license as circulated by CEA, CNRS and INRIA at the following URL 
#  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
#  or in the file LICENSE.txt.
#
#  As a counterpart to the access to the source code and  rights to copy,
#  modify and redistribute granted by the license, users are provided only
#  with a limited warranty  and the software's author,  the holder of the
#  economic rights,  and the successive licensors  have only  limited
#  liability. 
#
#  The fact that you are presently reading this means that you have had
#  knowledge of the CeCILL-B license and that you accept its terms.
# ------------------------------------------------------------------------
*/


#ifndef __creaImageIOQMultiThreadImageReader_h_INCLUDED__
#define __creaImageIOQMultiThreadImageReader_h_INCLUDED__

#include <creaImageIOSystem.h>
#include <creaImageIOImageReader.h>
#include <creaImageIOIndexedHeap.h>
#include <map>
#include <deque>
#include <QMutex>
#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 QMutex* GetMultiThreadImageReaderUserMutex() 
    { return &mMultiThreadImageReaderUserMutex; }
  private:
    void MultiThreadImageReaderSendEvent( const std::string& filename,
                                          EventType type,
                                          vtkImageData* image);
    QMutex 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);
   
        void getAttributes(const std::string filename, std::map <std::string , std::string> &infos, std::vector<std::string> i_attr);

  protected:
          bool mDone;
    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; }

          std::map<std::string, std::string> getAttributes(const std::vector<std::string> i_attr);
    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<boost::shared_ptr<ThreadedImageReader> > ThreadedImageReaderListType;
        //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 __creaImageIOQMultiThreadImageReader_h_INCLUDED__