Class that allows parallel lectures of several images. More...

#include <creaImageIOMultiThreadImageReader.h>

Inheritance diagram for creaImageIO::MultiThreadImageReader:

Collaboration diagram for creaImageIO::MultiThreadImageReader:

Classes
class	ImageToLoad
	Class that represents an image to be loaded. More...
struct	ImageToLoadPtrFilenameComparator
	ImageToLoadPtr comparator on filename (for image map). More...
struct	ImageToLoadPtrIndexer
	ImageToLoadPtr indexer for image queue. More...
struct	ImageToLoadPtrInversePriorityComparator
	ImageToLoadPtr comparator on inverse priority (for image to unload queue). More...
struct	ImageToLoadPtrPriorityComparator
	ImageToLoadPtr comparator on priority (for image queue). More...
struct	ImageToUnloadPtrIndexer
	ImageToLoadPtr indexer for to unload image queue. More...
Public Types
enum	EventType { ThreadedReaderStarted, ThreadedReaderStopped, ImageLoaded, ImageUnloaded, Error, ThreadedReaderStarted, ThreadedReaderStopped, ImageLoaded, ImageUnloaded, Error }
enum	EventType { ThreadedReaderStarted, ThreadedReaderStopped, ImageLoaded, ImageUnloaded, Error, ThreadedReaderStarted, ThreadedReaderStopped, ImageLoaded, ImageUnloaded, Error }
Public Member Functions
	MultiThreadImageReader (int number_of_threads=1)
	Ctor with the number of threads to use.
	~MultiThreadImageReader ()
	Dtor.
bool	Start ()
void	Stop ()
	Stops the reader = stops the threads and delete the images loaded.
void	Request (MultiThreadImageReaderUser *user, const std::string &filename, int priority)
vtkImageData *	GetImage (const std::string &filename)
	(no user callback but image returned)
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)
	Function to read attributes for a file.
	MultiThreadImageReader (int number_of_threads=1)
	Ctor with the number of threads to use.
	~MultiThreadImageReader ()
	Dtor.
bool	Start ()
void	Stop ()
	Stops the reader = stops the threads and delete the images loaded.
void	Request (MultiThreadImageReaderUser *user, const std::string &filename, int priority)
vtkImageData *	GetImage (const std::string &filename)
	(no user callback but image returned)
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)
	Function to read attributes for a file.
void	MultiThreadImageReaderEventLock ()
void	MultiThreadImageReaderEventLock ()
void	MultiThreadImageReaderEventUnlock ()
void	MultiThreadImageReaderEventUnlock ()
wxMutex &	GetMultiThreadImageReaderUserMutex ()
QMutex *	GetMultiThreadImageReaderUserMutex ()
Protected Types
typedef ImageToLoad *	ImageToLoadPtr
	Type of pointer on an ImageToLoad struct.
typedef std::map < ImageToLoadPtr, vtkImageData *, ImageToLoadPtrFilenameComparator >	ImageMapType
	The type of map of images.
typedef std::vector < boost::shared_ptr < ThreadedImageReader > >	ThreadedImageReaderListType
	The type of list of threaded readers.
typedef ImageToLoad *	ImageToLoadPtr
	Type of pointer on an ImageToLoad struct.
typedef std::map < ImageToLoadPtr, vtkImageData *, ImageToLoadPtrFilenameComparator >	ImageMapType
	The type of map of images.
typedef std::vector < boost::shared_ptr < ThreadedImageReader > >	ThreadedImageReaderListType
	The type of list of threaded readers.
Protected Member Functions
int	GetMaximalPriorityWithoutLocking ()
void	SignalImageRead (ImageToLoadPtr p, bool purge)
	The callback from threaded readers when an image is read.
void	UpdateUnloadPriority (ImageToLoadPtr p, int priority)
int	GetMaximalPriorityWithoutLocking ()
void	SignalImageRead (ImageToLoadPtr p, bool purge)
	The callback from threaded readers when an image is read.
void	UpdateUnloadPriority (ImageToLoadPtr p, int priority)
Protected Attributes
bool	mDone
ImageMapType	mImages
	The map of images.
ImageToLoadPtrPriorityComparator	mComparator
	Comparator for the image to load queue.
ImageToLoadPtrIndexer	mIndexer
	Indexer for the image to load queue.
IndexedHeap< ImageToLoadPtr, ImageToLoadPtrPriorityComparator, ImageToLoadPtrIndexer >	mQueue
	The image to load priority queue.
ThreadedImageReaderListType	mThreadedImageReaderList
int	mNumberOfThreadedReadersRunning
	The number of currently running threaded readers.
std::string	mRequestedFilename
	For GetImage : the filename requested.
vtkImageData *	mRequestedImage
	For GetImage : the image requested.
ImageReader *	mReader
	If number of threads == 0 then uses an internal non-threaded reader.
IndexedHeap< ImageToLoadPtr, ImageToLoadPtrInversePriorityComparator, ImageToUnloadPtrIndexer >	mUnloadQueue
	The image to unload priority queue.
long	mTotalMem
long	mTotalMemMax
Friends
class	ThreadedImageReader
class	MultiThreadImageReader

Detailed Description

Class that allows parallel lectures of several images.

TAKE CARE : For the moment it only supports a **SINGLE USER**

Definition at line 73 of file creaImageIOMultiThreadImageReader.h.

Member Typedef Documentation

typedef std::map<ImageToLoadPtr,vtkImageData*, ImageToLoadPtrFilenameComparator> creaImageIO::MultiThreadImageReader::ImageMapType [protected]

The type of map of images.

Definition at line 207 of file creaImageIOMultiThreadImageReader.h.

typedef std::map<ImageToLoadPtr,vtkImageData*, ImageToLoadPtrFilenameComparator> creaImageIO::MultiThreadImageReader::ImageMapType [protected]

The type of map of images.

Definition at line 207 of file creaImageIOQMultiThreadImageReader.h.

typedef ImageToLoad* creaImageIO::MultiThreadImageReader::ImageToLoadPtr [protected]

Type of pointer on an ImageToLoad struct.

Definition at line 159 of file creaImageIOMultiThreadImageReader.h.

typedef ImageToLoad* creaImageIO::MultiThreadImageReader::ImageToLoadPtr [protected]

Type of pointer on an ImageToLoad struct.

Definition at line 159 of file creaImageIOQMultiThreadImageReader.h.

typedef std::vector<boost::shared_ptr<ThreadedImageReader> > creaImageIO::MultiThreadImageReader::ThreadedImageReaderListType [protected]

The type of list of threaded readers.

Definition at line 220 of file creaImageIOMultiThreadImageReader.h.

typedef std::vector<boost::shared_ptr<ThreadedImageReader> > creaImageIO::MultiThreadImageReader::ThreadedImageReaderListType [protected]

The type of list of threaded readers.

Definition at line 220 of file creaImageIOQMultiThreadImageReader.h.

Member Enumeration Documentation

enum creaImageIO::MultiThreadImageReaderUser::EventType [inherited]

Enumerator:

ThreadedReaderStarted
ThreadedReaderStopped
ImageLoaded
ImageUnloaded
Error
ThreadedReaderStarted
ThreadedReaderStopped
ImageLoaded
ImageUnloaded
Error

Reimplemented in creaImageIO::WxGimmickView.

Definition at line 34 of file creaImageIOMultiThreadImageReader.h.

      {
        ThreadedReaderStarted,
        ThreadedReaderStopped,
        ImageLoaded,
        ImageUnloaded,
        Error
      }

enum creaImageIO::MultiThreadImageReaderUser::EventType [inherited]

Enumerator:

ThreadedReaderStarted
ThreadedReaderStopped
ImageLoaded
ImageUnloaded
Error
ThreadedReaderStarted
ThreadedReaderStopped
ImageLoaded
ImageUnloaded
Error

Reimplemented in creaImageIO::WxGimmickView.

Definition at line 34 of file creaImageIOQMultiThreadImageReader.h.

      {
        ThreadedReaderStarted,
        ThreadedReaderStopped,
        ImageLoaded,
        ImageUnloaded,
        Error
      }

Constructor & Destructor Documentation

creaImageIO::MultiThreadImageReader::MultiThreadImageReader ( int number_of_threads = 1 )

Ctor with the number of threads to use.

Definition at line 58 of file creaImageIOMultiThreadImageReader.cpp.

References mComparator, mDone, mIndexer, mNumberOfThreadedReadersRunning, mQueue, mReader, mThreadedImageReaderList, creaImageIO::IndexedHeap< T, Comparator, Indexer >::set(), and ThreadedImageReader.

    : //mDoNotSignal(false),
      mReader(0),
      mTotalMem(0),
      mTotalMemMax(1000000)
  {
    //    std::cout << "#### MultiThreadImageReader::MultiThreadImageReader("
    //        << " #threads= " << number_of_threads <<" )"<<std::endl;

          mDone = false;
    // Create the threads
    for (int i=0; i<number_of_threads; i++) 
      {
                  //ThreadedImageReader* t = new ThreadedImageReader(this);
                  boost::shared_ptr<ThreadedImageReader> t(new ThreadedImageReader(this), ThreadedImageReader::deleter());
        mThreadedImageReaderList.push_back(t);
         std::cout << "  ===> Thread "<<i
                      <<" successfully added"<< std::endl;
      }
    mNumberOfThreadedReadersRunning = 0;
    // Init the queue
    mQueue.set(mComparator);
    mQueue.set(mIndexer);
    // 
    // no thread : alloc self reader
//    if (number_of_threads==0)
//      {
        mReader = new ImageReader();
//      }
  }

Here is the call graph for this function:

creaImageIO::MultiThreadImageReader::~MultiThreadImageReader ( )

Dtor.

Definition at line 185 of file creaImageIOMultiThreadImageReader.cpp.

References mReader, mThreadedImageReaderList, and Stop().

  {
    //    std::cout << "#### MultiThreadImageReader::~MultiThreadImageReader()"
    //        <<std::endl;
    Stop();
    if (mReader) delete mReader;
        mThreadedImageReaderList.clear();
  }

Here is the call graph for this function:

creaImageIO::MultiThreadImageReader::MultiThreadImageReader ( int number_of_threads = 1 )

Ctor with the number of threads to use.

creaImageIO::MultiThreadImageReader::~MultiThreadImageReader ( )

Dtor.

Member Function Documentation

void creaImageIO::MultiThreadImageReader::getAttributes	(	const std::string	filename,
		std::map< std::string, std::string > &	infos,
		std::vector< std::string >	i_attr
	)

Function to read attributes for a file.

Definition at line 215 of file creaImageIOMultiThreadImageReader.cpp.

References creaImageIO::ImageReader::getAttributes(), and mReader.

Referenced by creaImageIO::GimmickView::getAttributes().

  {
          mReader->getAttributes(filename, infos, i_attr);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void creaImageIO::MultiThreadImageReader::getAttributes	(	const std::string	filename,
		std::map< std::string, std::string > &	infos,
		std::vector< std::string >	i_attr
	)

Function to read attributes for a file.

vtkImageData * creaImageIO::MultiThreadImageReader::GetImage ( const std::string & filename )

(no user callback but image returned)

Request the image "filename" immediately Blocks until image loaded

Definition at line 319 of file creaImageIOMultiThreadImageReader.cpp.

References creaImageIO::MultiThreadImageReader::ImageToLoad::GetImage(), GetMaximalPriorityWithoutLocking(), mImages, mReader, creaImageIO::ImageReader::ReadImage(), creaImageIO::MultiThreadImageReader::ImageToLoad::SetImage(), and UpdateUnloadPriority().

Referenced by creaImageIO::GimmickView::GetDefaultImage(), creaImageIO::GimmickView::isSingle(), creaImageIO::GimmickView::readImages1(), creaImageIO::GimmickView::readImages2(), creaImageIO::GimmickView::readImages3(), creaImageIO::GimmickView::readImages4(), creaImageIO::GimmickView::ReadImagesNotThreaded(), and creaImageIO::GimmickView::ReadImagesNotThreadedInVector().

  {
         // Start();
    //       std::cout << "** MultiThreadImageReader::GetImage('"<<filename<<"')"
    //           <<std::endl;
    
    do 
      {
        //      wxMutexLocker lock(GetMultiThreadImageReaderUserMutex()); //mMutex);
                
        //     std::cout << "** MultiThreadImageReader::GetImage('"<<filename
        //             <<"') lock ok"
        //               <<std::endl;
    
        //                if (mNumberOfThreadedReadersRunning==0)
        //      if (mThreadedImageReaderList.size()==0)
        if (true)
          {
            ImageToLoad itl(this,filename);
            ImageMapType::iterator i = mImages.find(&itl);
            if (i!=mImages.end())
              {
                ImageToLoadPtr pitl = const_cast<ImageToLoadPtr>(i->first);
                // Already inserted
                if (pitl->GetImage() != 0)
                  {
                    // Already read
                    UpdateUnloadPriority(pitl,
                                         GetMaximalPriorityWithoutLocking()+1);
                    return pitl->GetImage();
                  }
              }
            ImageToLoadPtr pitl = new ImageToLoad(this,filename,0);
            mImages[pitl] = 0;
            pitl->SetImage(mReader->ReadImage(filename));
            UpdateUnloadPriority(pitl,
                                 GetMaximalPriorityWithoutLocking()+1);
            return pitl->GetImage();
          }

        /*      
        mRequestedFilename = filename;
        mRequestedImage = 0;
        ImageToLoad itl(this,filename);
        ImageMapType::iterator i = mImages.find(&itl);
        if (i!=mImages.end())
          {
            // Already inserted in queue
            if (i->first->GetImage() != 0)
              {
                // Already read : ok : return it 
                return i->first->GetImage();
              }
              ImageToLoadPtr pitl = const_cast<ImageToLoadPtr>(i->first);
              pitl->SetPriority( GetMaximalPriorityWithoutLocking() + 1 );
              pitl->SetUser( this );
              // Already in queue
              if (pitl->Index()>=0) 
                {
                  // Re-sort the queue
                  mQueue.upsort(pitl->Index());
                }
              // Not read but not in queue = being read = ok
              else 
                {
                  pitl->SetUser( this );
                }
          }
        else 
          {
            
            // Never requested before or unloaded 
            ImageToLoadPtr pitl = 
              new ImageToLoad(this,filename,
                              GetMaximalPriorityWithoutLocking() + 1);
            mImages[pitl] = 0;
            mQueue.insert(pitl);
          }
        */
      }
    while (0);

    //    std::cout << "Waiting..."<<std::endl;

    /*
    // Waiting that it is read
    int n = 0;
    do 
      {
        //      std::cout << n++ << std::endl;
        wxMilliSleep(10);
        do 
          {
            //      wxMutexLocker lock(mMutex);
            wxMutexLocker lock(GetMultiThreadImageReaderUserMutex());
            if (mRequestedImage!=0) 
              {
                return mRequestedImage;
              } 
          }
        while (0);
      }
    while (true);
    // 
    */
  }

Here is the call graph for this function:

Here is the caller graph for this function:

vtkImageData* creaImageIO::MultiThreadImageReader::GetImage ( const std::string & filename )

(no user callback but image returned)

Request the image "filename" immediately Blocks until image loaded

int creaImageIO::MultiThreadImageReader::GetMaximalPriority ( )

Definition at line 529 of file creaImageIOMultiThreadImageReader.cpp.

References GetMaximalPriorityWithoutLocking(), and creaImageIO::MultiThreadImageReaderUser::GetMultiThreadImageReaderUserMutex().

Referenced by creaImageIO::GimmickView::GetMaximalPriority().

  { 
    wxMutexLocker lock(GetMultiThreadImageReaderUserMutex()); //mMutex);
    return GetMaximalPriorityWithoutLocking();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

int creaImageIO::MultiThreadImageReader::GetMaximalPriority ( )

int creaImageIO::MultiThreadImageReader::GetMaximalPriorityWithoutLocking ( ) [protected]

Definition at line 538 of file creaImageIOMultiThreadImageReader.cpp.

References creaImageIO::MultiThreadImageReader::ImageToLoad::GetPriority(), mQueue, mUnloadQueue, creaImageIO::IndexedHeap< T, Comparator, Indexer >::size(), and creaImageIO::IndexedHeap< T, Comparator, Indexer >::top().

Referenced by GetImage(), and GetMaximalPriority().

  { 
    long max = 0;
    if (mQueue.size()>0) 
      {
        max = mQueue.top()->GetPriority();
      }
    if (mUnloadQueue.size()>0)
      {
        int max2 = mUnloadQueue.top()->GetPriority();
        if (max2>max) max=max2;
      }
    return max;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

int creaImageIO::MultiThreadImageReader::GetMaximalPriorityWithoutLocking ( ) [protected]

wxMutex& creaImageIO::MultiThreadImageReaderUser::GetMultiThreadImageReaderUserMutex ( ) [inline, inherited]

Definition at line 57 of file creaImageIOMultiThreadImageReader.h.

Referenced by GetMaximalPriority(), Request(), SignalImageRead(), Start(), and Stop().

    { return mMultiThreadImageReaderUserMutex; }

Here is the caller graph for this function:

QMutex* creaImageIO::MultiThreadImageReaderUser::GetMultiThreadImageReaderUserMutex ( ) [inline, inherited]

Definition at line 57 of file creaImageIOQMultiThreadImageReader.h.

    { return &mMultiThreadImageReaderUserMutex; }

void creaImageIO::MultiThreadImageReaderUser::MultiThreadImageReaderEventLock ( ) [inline, inherited]

Definition at line 53 of file creaImageIOMultiThreadImageReader.h.

Referenced by creaImageIO::ThreadedImageReader::Entry().

    { mMultiThreadImageReaderUserMutex.Lock(); }

Here is the caller graph for this function:

void creaImageIO::MultiThreadImageReaderUser::MultiThreadImageReaderEventLock ( ) [inline, inherited]

Definition at line 53 of file creaImageIOQMultiThreadImageReader.h.

    { mMultiThreadImageReaderUserMutex.lock(); }

void creaImageIO::MultiThreadImageReaderUser::MultiThreadImageReaderEventUnlock ( ) [inline, inherited]

Definition at line 55 of file creaImageIOMultiThreadImageReader.h.

Referenced by creaImageIO::ThreadedImageReader::Entry().

    { mMultiThreadImageReaderUserMutex.Unlock(); }

Here is the caller graph for this function:

void creaImageIO::MultiThreadImageReaderUser::MultiThreadImageReaderEventUnlock ( ) [inline, inherited]

Definition at line 55 of file creaImageIOQMultiThreadImageReader.h.

    { mMultiThreadImageReaderUserMutex.unlock(); }

void creaImageIO::MultiThreadImageReader::OnMultiThreadImageReaderEvent	(	const std::string &	filename,
		EventType	type,
		vtkImageData *	image
	)			`[virtual]`

The virtual method to overload by MultiThreadImageReader users It is called when an image has been loaded or unloaded Provides : The image file name which was requested The type of event If type==ImageLoaded the image pointer, else NULL pointer

Reimplemented from creaImageIO::MultiThreadImageReaderUser.

void creaImageIO::MultiThreadImageReader::OnMultiThreadImageReaderEvent	(	const std::string &	filename,
		MultiThreadImageReaderUser::EventType	type,
		vtkImageData *	image
	)			`[virtual]`

The virtual method to overload by MultiThreadImageReader users It is called when an image has been loaded or unloaded Provides : The image file name which was requested The type of event If type==ImageLoaded the image pointer, else NULL pointer

Reimplemented from creaImageIO::MultiThreadImageReaderUser.

Definition at line 295 of file creaImageIOMultiThreadImageReader.cpp.

References creaImageIO::MultiThreadImageReaderUser::ImageLoaded, creaImageIO::MultiThreadImageReaderUser::ThreadedReaderStarted, and creaImageIO::MultiThreadImageReaderUser::ThreadedReaderStopped.

  {
    if ((e==MultiThreadImageReaderUser::ImageLoaded) &&
        (filename == mRequestedFilename))
      {
        mRequestedImage = image;
      }
    else if (e==MultiThreadImageReaderUser::ThreadedReaderStarted)
      {
        mNumberOfThreadedReadersRunning++;
        //      std::cout << "#TR=" << mNumberOfThreadedReadersRunning << std::endl;
      }
    else if (e==MultiThreadImageReaderUser::ThreadedReaderStopped)
      {
        
                 mNumberOfThreadedReadersRunning--;
        //      std::cout << "#TR=" << mNumberOfThreadedReadersRunning << std::endl;
      }
  }

void creaImageIO::MultiThreadImageReader::Request	(	MultiThreadImageReaderUser *	user,
		const std::string &	filename,
		int	priority
	)

Request the image "filename" with a given priority When the image is ready (or an error occurred) The observer's callback is invoked

void creaImageIO::MultiThreadImageReader::Request	(	MultiThreadImageReaderUser *	user,
		const std::string &	filename,
		int	priority
	)

Request the image "filename" with a given priority When the image is ready (or an error occurred) The observer's callback is invoked

Already requested : change the priority

Definition at line 222 of file creaImageIOMultiThreadImageReader.cpp.

References creaImageIO::MultiThreadImageReader::ImageToLoad::GetImage(), creaImageIO::MultiThreadImageReaderUser::GetMultiThreadImageReaderUserMutex(), creaImageIO::MultiThreadImageReader::ImageToLoad::Index(), creaImageIO::IndexedHeap< T, Comparator, Indexer >::insert(), mImages, mNumberOfThreadedReadersRunning, mQueue, mReader, creaImageIO::ImageReader::ReadImage(), creaImageIO::MultiThreadImageReader::ImageToLoad::SetImage(), creaImageIO::MultiThreadImageReader::ImageToLoad::SetPriority(), creaImageIO::MultiThreadImageReader::ImageToLoad::SetUser(), SignalImageRead(), UpdateUnloadPriority(), and creaImageIO::IndexedHeap< T, Comparator, Indexer >::upsort().

Referenced by creaImageIO::GimmickView::RequestReading().

  {
        wxMutexLocker lock(GetMultiThreadImageReaderUserMutex()); //mMutex);

          if (mNumberOfThreadedReadersRunning==0)
//    if (mThreadedImageReaderList.size()==0) 
      {
        // no detached reader : use self reader
        ImageToLoad itl(user,filename);
        ImageMapType::iterator i = mImages.find(&itl);
        if (i!=mImages.end())
          {
            ImageToLoadPtr pitl = const_cast<ImageToLoadPtr>(i->first);
            // Already inserted
            if (pitl->GetImage() != 0)
              {
                // Already read
                pitl->SetUser(user);
                UpdateUnloadPriority(pitl,priority);
                SignalImageRead(pitl,false);
                return; // pitl->GetImage();
              }
          }
        ImageToLoadPtr pitl = new ImageToLoad(user,filename,0);
        mImages[pitl] = 0;
        pitl->SetImage(mReader->ReadImage(filename));
        UpdateUnloadPriority(pitl,priority);
        SignalImageRead(pitl,true);
        //      return pitl->GetImage();
        return;
      }

    ImageToLoad itl(user,filename);
    ImageMapType::iterator i = mImages.find(&itl);
    if (i!=mImages.end())
      {
        // Already inserted
        if (i->first->GetImage() != 0)
          {
            // Already read : ok :signal the user
            UpdateUnloadPriority(i->first,priority);
            SignalImageRead(i->first,false);
            return;
          }
        ImageToLoadPtr pitl = const_cast<ImageToLoadPtr>(i->first);
        pitl->SetPriority(priority);
        // Already in queue
        if (pitl->Index()>=0) 
          {
            // Re-sort the queue
            mQueue.upsort(pitl->Index());
          }
        // Not read but not in queue = being read = ok
        else 
          {
            
          }
      }
    else 
      {
        // Never requested before or unloaded 
        ImageToLoadPtr pitl = new ImageToLoad(user,filename,priority);
        mImages[pitl] = 0;
        mQueue.insert(pitl);
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void creaImageIO::MultiThreadImageReader::SignalImageRead	(	ImageToLoadPtr	p,
		bool	purge
	)			`[protected]`

The callback from threaded readers when an image is read.

Definition at line 429 of file creaImageIOMultiThreadImageReader.cpp.

References creaImageIO::MultiThreadImageReader::ImageToLoad::GetFilename(), creaImageIO::MultiThreadImageReader::ImageToLoad::GetImage(), creaImageIO::MultiThreadImageReaderUser::GetMultiThreadImageReaderUserMutex(), creaImageIO::MultiThreadImageReader::ImageToLoad::GetUser(), GimmickMessage, creaImageIO::MultiThreadImageReaderUser::ImageUnloaded, creaImageIO::MultiThreadImageReader::ImageToLoad::Index(), creaImageIO::IndexedHeap< T, Comparator, Indexer >::insert(), mImages, mTotalMem, mTotalMemMax, creaImageIO::MultiThreadImageReaderUser::MultiThreadImageReaderSendEvent(), mUnloadQueue, creaImageIO::IndexedHeap< T, Comparator, Indexer >::remove_top(), and creaImageIO::IndexedHeap< T, Comparator, Indexer >::size().

Referenced by creaImageIO::ThreadedImageReader::Entry(), and Request().

  {
    
//    std::cout << "MultiThreadImageReader::SignalImageRead" <<std::endl;
    //    std::cout << "this="<<this <<std::endl;
    //    std::cout << "user="<<p->GetUser() <<std::endl;

    if ( p->GetUser() == this ) 
      GetMultiThreadImageReaderUserMutex().Unlock();

    p->GetUser()->MultiThreadImageReaderSendEvent
      (p->GetFilename(),
       MultiThreadImageReaderUser::ImageLoaded,
       p->GetImage());

    /*
      AN ATTEMPT TO UNLOAD OLDEST IMAGE IF EXCEEDED A CERTAIN MEMORY QUOTA
      BUGGY : TO FIX 
    */
    if (!purge)  return;
    GimmickMessage(5,"Image '"<<p->GetFilename()<<"' read"<<std::endl);

    //    wxMutexLocker lock(GetMultiThreadImageReaderUserMutex());
           
    mUnloadQueue.insert(p);
    p->GetImage()->UpdateInformation();
    p->GetImage()->PropagateUpdateExtent();
    long ImMem = p->GetImage()->GetEstimatedMemorySize();
    mTotalMem += ImMem;

    GimmickMessage(5,"==> Image in memory = "<<mUnloadQueue.size()<<std::endl);
    GimmickMessage(5,"==> Total mem       = "<<mTotalMem<<" Ko"<<std::endl);

    //  return;

    while (mTotalMem > mTotalMemMax)
      {
        GimmickMessage(5,
                       "   ! Exceeded max of "
                       << mTotalMemMax << " Ko : unloading oldest image ... "
                       << std::endl);
        if ( mUnloadQueue.size() <= 1 ) 
          {
             GimmickMessage(5,
                            "   Only one image : cannot load AND unload it !!"
                            <<std::endl);
            break; 
            
          }
        ImageToLoadPtr unload = mUnloadQueue.remove_top();
        MultiThreadImageReaderUser* user = unload->GetUser();

        /*
        if ((user!=0)&&(user!=this)) 
          {
            user->GetMultiThreadImageReaderUserMutex().Lock();
          }
        */

        std::string filename = unload->GetFilename();

        GimmickMessage(5,"'" << filename << "'" << std::endl);
        mTotalMem -= unload->GetImage()->GetEstimatedMemorySize();

        GimmickMessage(5," ==> Total mem = "<<mTotalMem<<" Ko "<<std::endl);

        if (user!=0) 
          {
            //      std::cout << "unlock..."<<std::endl;
            //   user->GetMultiThreadImageReaderUserMutex().Unlock();
            //      std::cout << "event"<<std::endl;
            user->MultiThreadImageReaderSendEvent
              (filename,
               MultiThreadImageReaderUser::ImageUnloaded,
               0);
            //      std::cout << "event ok"<<std::endl;
          }     

        if (unload->Index()>=0)
          {
            // GimmickMessage(5,"still in queue"<<std::endl);
          }
        unload->Index() = -1;


        ImageMapType::iterator it = mImages.find(unload);
        if (it!=mImages.end())
          {
            mImages.erase(it);
          }
        //          std::cout << "delete..."<<std::endl;
        delete unload;
        //          std::cout << "delete ok."<<std::endl;

      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void creaImageIO::MultiThreadImageReader::SignalImageRead	(	ImageToLoadPtr	p,
		bool	purge
	)			`[protected]`

The callback from threaded readers when an image is read.

bool creaImageIO::MultiThreadImageReader::Start ( )

Starts the reader = create the threads which start to check periodically the queue of requested images to read

bool creaImageIO::MultiThreadImageReader::Start ( )

Starts the reader = create the threads which start to check periodically the queue of requested images to read

Definition at line 92 of file creaImageIOMultiThreadImageReader.cpp.

References creaImageIO::MultiThreadImageReaderUser::GetMultiThreadImageReaderUserMutex(), mNumberOfThreadedReadersRunning, and mThreadedImageReaderList.

Referenced by creaImageIO::GimmickView::RequestReading().

  {

    //    std::cout << "#### MultiThreadImageReader::Start()"
    //                <<std::endl;
          if (mNumberOfThreadedReadersRunning > 0) return true;
          
    ThreadedImageReaderListType::iterator i;
    for (i =mThreadedImageReaderList.begin();
         i!=mThreadedImageReaderList.end();
         i++)
      {
        (*i)->Create();
        if ( (*i)->Run() != wxTHREAD_NO_ERROR )
          {
            std::cout << "ERROR starting a thread"<< std::endl;
            return false;
          }
        else 
          {
                    std::cout << "  ===> Thread "<<(*i)->GetCurrentId()
                              <<" successfully created"<< std::endl;
            
          }
      }
    wxMutexLocker locker(GetMultiThreadImageReaderUserMutex());
    //    std::cout << "EO Start : #Threads running = "
    //                << mNumberOfThreadedReadersRunning<<std::endl;

    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void creaImageIO::MultiThreadImageReader::Stop ( )

Stops the reader = stops the threads and delete the images loaded.

Definition at line 126 of file creaImageIOMultiThreadImageReader.cpp.

References creaImageIO::MultiThreadImageReaderUser::GetMultiThreadImageReaderUserMutex(), mDone, mImages, mNumberOfThreadedReadersRunning, and mThreadedImageReaderList.

Referenced by creaImageIO::GimmickView::stopReader(), and ~MultiThreadImageReader().

  { 
//                  std::cout << "#### MultiThreadImageReader::Stop()"
//            <<std::endl;
  //  std::cout << "Sending stop order to the threads..."<<std::endl;
          if (mDone) return;

    ThreadedImageReaderListType::iterator i;
    for (i =mThreadedImageReaderList.begin();
         i!=mThreadedImageReaderList.end();
         i++)
      { std::cout << "  ===> Thread "<<(*i)->GetCurrentId()
                              <<" successfully stopped"<< std::endl;
                  if((*i)->IsAlive())
                  {(*i)->Pause();
                          (*i).reset();
                         //                       (*i)->Delete();
                  }
      }
   mThreadedImageReaderList.clear();
    // Wait a little to be sure that all threads have stopped
    // A better way to do this ?
    //    wxMilliSleep(1000);
    // New method : the threads generate a stop event when they have finished
    // We wait until all threads have stopped
//        std::cout << "Waiting for stop signals..."<<std::endl;
    do 
      {
        // Sleep a little
                wxMilliSleep(10);
        // Lock
        {
          wxMutexLocker locker(GetMultiThreadImageReaderUserMutex());
//                std::cout << "#Threads running = "
//                          << mNumberOfThreadedReadersRunning<<std::endl;
          // Break if all readers have stopped
          if (mNumberOfThreadedReadersRunning <= 0) 
            {
              break;
            }
        }
      } 
    while (true);
//        std::cout << "All threads stopped : OK "<<std::endl;

    ImageMapType::iterator j;
    for (j =mImages.begin();
         j!=mImages.end();
         ++j)

      {
        delete j->first;
      }
    mImages.clear();
        mDone = true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void creaImageIO::MultiThreadImageReader::Stop ( )

Stops the reader = stops the threads and delete the images loaded.

void creaImageIO::MultiThreadImageReader::UpdateUnloadPriority	(	ImageToLoadPtr	p,
		int	priority
	)			`[protected]`

Definition at line 196 of file creaImageIOMultiThreadImageReader.cpp.

References creaImageIO::IndexedHeap< T, Comparator, Indexer >::downsort(), creaImageIO::MultiThreadImageReader::ImageToLoad::GetPriority(), mUnloadQueue, creaImageIO::MultiThreadImageReader::ImageToLoad::SetPriority(), creaImageIO::MultiThreadImageReader::ImageToLoad::UnloadIndex(), and creaImageIO::IndexedHeap< T, Comparator, Indexer >::upsort().

Referenced by GetImage(), and Request().

  {
    // not in unload queue : ciao
    if (p->UnloadIndex()<0) return;
    int old_prio = p->GetPriority();
    if (priority > old_prio) 
      {
        p->SetPriority(priority);
        mUnloadQueue.downsort(p->UnloadIndex());
      }
    else if ( old_prio > priority )
      {
        p->SetPriority(priority);
        mUnloadQueue.upsort(p->UnloadIndex());
     }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void creaImageIO::MultiThreadImageReader::UpdateUnloadPriority	(	ImageToLoadPtr	p,
		int	priority
	)			`[protected]`

Friends And Related Function Documentation

MultiThreadImageReader [friend, inherited]

Definition at line 29 of file creaImageIOMultiThreadImageReader.h.

ThreadedImageReader [friend]

Reimplemented from creaImageIO::MultiThreadImageReaderUser.

Definition at line 76 of file creaImageIOMultiThreadImageReader.h.

Referenced by MultiThreadImageReader().

Member Data Documentation

ImageToLoadPtrPriorityComparator creaImageIO::MultiThreadImageReader::mComparator [protected]

Comparator for the image to load queue.

Definition at line 211 of file creaImageIOMultiThreadImageReader.h.

Referenced by MultiThreadImageReader().

bool creaImageIO::MultiThreadImageReader::mDone [protected]

Definition at line 113 of file creaImageIOMultiThreadImageReader.h.

Referenced by MultiThreadImageReader(), and Stop().

ImageMapType creaImageIO::MultiThreadImageReader::mImages [protected]

The map of images.

Definition at line 209 of file creaImageIOMultiThreadImageReader.h.

Referenced by creaImageIO::ThreadedImageReader::Entry(), GetImage(), Request(), SignalImageRead(), and Stop().

ImageToLoadPtrIndexer creaImageIO::MultiThreadImageReader::mIndexer [protected]

Indexer for the image to load queue.

Definition at line 213 of file creaImageIOMultiThreadImageReader.h.

Referenced by MultiThreadImageReader().

int creaImageIO::MultiThreadImageReader::mNumberOfThreadedReadersRunning [protected]

The number of currently running threaded readers.

Definition at line 224 of file creaImageIOMultiThreadImageReader.h.

Referenced by MultiThreadImageReader(), Request(), Start(), and Stop().

IndexedHeap< ImageToLoadPtr, ImageToLoadPtrPriorityComparator, ImageToLoadPtrIndexer > creaImageIO::MultiThreadImageReader::mQueue [protected]

The image to load priority queue.

Definition at line 217 of file creaImageIOMultiThreadImageReader.h.

Referenced by creaImageIO::ThreadedImageReader::Entry(), GetMaximalPriorityWithoutLocking(), MultiThreadImageReader(), and Request().

ImageReader * creaImageIO::MultiThreadImageReader::mReader [protected]

If number of threads == 0 then uses an internal non-threaded reader.

Definition at line 236 of file creaImageIOMultiThreadImageReader.h.

Referenced by getAttributes(), GetImage(), MultiThreadImageReader(), Request(), and ~MultiThreadImageReader().

std::string creaImageIO::MultiThreadImageReader::mRequestedFilename [protected]

For GetImage : the filename requested.

The mutex used to access safely internal data from any thread LG : Removed ! We now use the embedded mutex in User from which we inherit...

Definition at line 231 of file creaImageIOMultiThreadImageReader.h.

vtkImageData * creaImageIO::MultiThreadImageReader::mRequestedImage [protected]

For GetImage : the image requested.

Definition at line 233 of file creaImageIOMultiThreadImageReader.h.

ThreadedImageReaderListType creaImageIO::MultiThreadImageReader::mThreadedImageReaderList [protected]

Definition at line 222 of file creaImageIOMultiThreadImageReader.h.

Referenced by MultiThreadImageReader(), Start(), Stop(), and ~MultiThreadImageReader().

long creaImageIO::MultiThreadImageReader::mTotalMem [protected]

Definition at line 246 of file creaImageIOMultiThreadImageReader.h.

Referenced by SignalImageRead().

long creaImageIO::MultiThreadImageReader::mTotalMemMax [protected]

Definition at line 247 of file creaImageIOMultiThreadImageReader.h.

Referenced by SignalImageRead().

IndexedHeap< ImageToLoadPtr, ImageToLoadPtrInversePriorityComparator, ImageToUnloadPtrIndexer > creaImageIO::MultiThreadImageReader::mUnloadQueue [protected]

The image to unload priority queue.

The type of list of images loaded used to unload oldest image when memory limit exceeded

Definition at line 243 of file creaImageIOMultiThreadImageReader.h.

Referenced by GetMaximalPriorityWithoutLocking(), SignalImageRead(), and UpdateUnloadPriority().

The documentation for this class was generated from the following files:

/home/davila/Creatis/All7/creatools_source/creaImageIO/src/creaImageIOMultiThreadImageReader.h
/home/davila/Creatis/All7/creatools_source/creaImageIO/src/creaImageIOQMultiThreadImageReader.h
/home/davila/Creatis/All7/creatools_source/creaImageIO/src/creaImageIOMultiThreadImageReader.cpp
/home/davila/Creatis/All7/creatools_source/creaImageIO/src/creaImageIOQMultiThreadImageReader.cpp

creaImageIO::MultiThreadImageReader Class Reference

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation