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. More...

	~MultiThreadImageReader ()
	Dtor. More...

bool	Start ()

void	Stop ()
	Stops the reader = stops the threads and delete the images loaded. More...

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

vtkImageData *	GetImage (const std::string &filename)
	(no user callback but image returned) More...

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. More...

	MultiThreadImageReader (int number_of_threads=1)
	Ctor with the number of threads to use. More...

	~MultiThreadImageReader ()
	Dtor. More...

bool	Start ()

void	Stop ()
	Stops the reader = stops the threads and delete the images loaded. More...

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

vtkImageData *	GetImage (const std::string &filename)
	(no user callback but image returned) More...

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. More...

void	MultiThreadImageReaderEventLock ()

void	MultiThreadImageReaderEventLock ()

void	MultiThreadImageReaderEventUnlock ()

void	MultiThreadImageReaderEventUnlock ()

wxMutex &	GetMultiThreadImageReaderUserMutex ()

QMutex *	GetMultiThreadImageReaderUserMutex ()

Protected Types
typedef ImageToLoad *	ImageToLoadPtr
	Type of pointer on an ImageToLoad struct. More...

typedef std::map < ImageToLoadPtr, vtkImageData *, ImageToLoadPtrFilenameComparator >	ImageMapType
	The type of map of images. More...

typedef std::vector < boost::shared_ptr < ThreadedImageReader > >	ThreadedImageReaderListType
	The type of list of threaded readers. More...

typedef ImageToLoad *	ImageToLoadPtr
	Type of pointer on an ImageToLoad struct. More...

typedef std::map < ImageToLoadPtr, vtkImageData *, ImageToLoadPtrFilenameComparator >	ImageMapType
	The type of map of images. More...

typedef std::vector < boost::shared_ptr < ThreadedImageReader > >	ThreadedImageReaderListType
	The type of list of threaded readers. More...

Protected Member Functions
int	GetMaximalPriorityWithoutLocking ()

void	SignalImageRead (ImageToLoadPtr p, bool purge)
	The callback from threaded readers when an image is read. More...

void	UpdateUnloadPriority (ImageToLoadPtr p, int priority)

int	GetMaximalPriorityWithoutLocking ()

void	SignalImageRead (ImageToLoadPtr p, bool purge)
	The callback from threaded readers when an image is read. More...

void	UpdateUnloadPriority (ImageToLoadPtr p, int priority)

Protected Attributes
bool	mDone

ImageMapType	mImages
	The map of images. More...

ImageToLoadPtrPriorityComparator	mComparator
	Comparator for the image to load queue. More...

ImageToLoadPtrIndexer	mIndexer
	Indexer for the image to load queue. More...

IndexedHeap< ImageToLoadPtr, ImageToLoadPtrPriorityComparator, ImageToLoadPtrIndexer >	mQueue
	The image to load priority queue. More...

ThreadedImageReaderListType	mThreadedImageReaderList

int	mNumberOfThreadedReadersRunning
	The number of currently running threaded readers. More...

std::string	mRequestedFilename
	For GetImage : the filename requested. More...

vtkImageData *	mRequestedImage
	For GetImage : the image requested. More...

ImageReader *	mReader
	If number of threads == 0 then uses an internal non-threaded reader. More...

IndexedHeap< ImageToLoadPtr, ImageToLoadPtrInversePriorityComparator, ImageToUnloadPtrIndexer >	mUnloadQueue
	The image to unload priority queue. More...

long	mTotalMem

long	mTotalMemMax

Friends
class	ThreadedImageReader

Detailed Description

Class that allows parallel lectures of several images.

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

Definition at line 100 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 234 of file creaImageIOMultiThreadImageReader.h.

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

protected

The type of map of images.

Definition at line 235 of file creaImageIOQMultiThreadImageReader.h.

typedef ImageToLoad* creaImageIO::MultiThreadImageReader::ImageToLoadPtr

protected

Type of pointer on an ImageToLoad struct.

Definition at line 186 of file creaImageIOMultiThreadImageReader.h.

typedef ImageToLoad* creaImageIO::MultiThreadImageReader::ImageToLoadPtr

protected

Type of pointer on an ImageToLoad struct.

Definition at line 187 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 247 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 248 of file creaImageIOQMultiThreadImageReader.h.

Member Enumeration Documentation

enum creaImageIO::MultiThreadImageReaderUser::EventType

inherited

Enumerator
ThreadedReaderStarted
ThreadedReaderStopped
ImageLoaded
ImageUnloaded
Error
ThreadedReaderStarted
ThreadedReaderStopped
ImageLoaded
ImageUnloaded
Error

Definition at line 61 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

Definition at line 62 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 86 of file creaImageIOMultiThreadImageReader.cpp.

References mComparator, mDone, mIndexer, mNumberOfThreadedReadersRunning, mQueue, mReader, mThreadedImageReaderList, 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();
 //      }
   }

creaImageIO::MultiThreadImageReader::~MultiThreadImageReader ( )

Dtor.

Definition at line 213 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 243 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 347 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 557 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 566 of file creaImageIOMultiThreadImageReader.cpp.

References mQueue, and mUnloadQueue.

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 caller graph for this function:

int creaImageIO::MultiThreadImageReader::GetMaximalPriorityWithoutLocking ( )

protected

wxMutex& creaImageIO::MultiThreadImageReaderUser::GetMultiThreadImageReaderUserMutex ( )

inlineinherited

Definition at line 84 of file creaImageIOMultiThreadImageReader.h.

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

85 { return mMultiThreadImageReaderUserMutex; }

Here is the caller graph for this function:

QMutex* creaImageIO::MultiThreadImageReaderUser::GetMultiThreadImageReaderUserMutex ( )

inlineinherited

Definition at line 85 of file creaImageIOQMultiThreadImageReader.h.

86 { return &mMultiThreadImageReaderUserMutex; }

void creaImageIO::MultiThreadImageReaderUser::MultiThreadImageReaderEventLock ( )

inlineinherited

Definition at line 80 of file creaImageIOMultiThreadImageReader.h.

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

81 { mMultiThreadImageReaderUserMutex.Lock(); }

Here is the caller graph for this function:

void creaImageIO::MultiThreadImageReaderUser::MultiThreadImageReaderEventLock ( )

inlineinherited

Definition at line 81 of file creaImageIOQMultiThreadImageReader.h.

82 { mMultiThreadImageReaderUserMutex.lock(); }

void creaImageIO::MultiThreadImageReaderUser::MultiThreadImageReaderEventUnlock ( )

inlineinherited

Definition at line 82 of file creaImageIOMultiThreadImageReader.h.

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

83 { mMultiThreadImageReaderUserMutex.Unlock(); }

Here is the caller graph for this function:

void creaImageIO::MultiThreadImageReaderUser::MultiThreadImageReaderEventUnlock ( )

inlineinherited

Definition at line 83 of file creaImageIOQMultiThreadImageReader.h.

84 { mMultiThreadImageReaderUserMutex.unlock(); }

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 323 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::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::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 250 of file creaImageIOMultiThreadImageReader.cpp.

References creaImageIO::MultiThreadImageReader::ImageToLoad::GetImage(), creaImageIO::MultiThreadImageReaderUser::GetMultiThreadImageReaderUserMutex(), creaImageIO::MultiThreadImageReader::ImageToLoad::Index(), mImages, mNumberOfThreadedReadersRunning, mQueue, mReader, creaImageIO::ImageReader::ReadImage(), creaImageIO::MultiThreadImageReader::ImageToLoad::SetImage(), creaImageIO::MultiThreadImageReader::ImageToLoad::SetPriority(), creaImageIO::MultiThreadImageReader::ImageToLoad::SetUser(), SignalImageRead(), and UpdateUnloadPriority().

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::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::SignalImageRead	(	ImageToLoadPtr	p,
		bool	purge
	)

protected

The callback from threaded readers when an image is read.

Definition at line 457 of file creaImageIOMultiThreadImageReader.cpp.

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

Definition at line 120 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:

bool creaImageIO::MultiThreadImageReader::Start ( )

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

void creaImageIO::MultiThreadImageReader::Stop ( )

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

Definition at line 154 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 224 of file creaImageIOMultiThreadImageReader.cpp.

References creaImageIO::MultiThreadImageReader::ImageToLoad::GetPriority(), mUnloadQueue, creaImageIO::MultiThreadImageReader::ImageToLoad::SetPriority(), and creaImageIO::MultiThreadImageReader::ImageToLoad::UnloadIndex().

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

ThreadedImageReader

friend

Definition at line 103 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 238 of file creaImageIOMultiThreadImageReader.h.

Referenced by MultiThreadImageReader().

bool creaImageIO::MultiThreadImageReader::mDone

protected

Definition at line 140 of file creaImageIOMultiThreadImageReader.h.

Referenced by MultiThreadImageReader(), and Stop().

ImageMapType creaImageIO::MultiThreadImageReader::mImages

protected

The map of images.

Definition at line 236 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 240 of file creaImageIOMultiThreadImageReader.h.

Referenced by MultiThreadImageReader().

int creaImageIO::MultiThreadImageReader::mNumberOfThreadedReadersRunning

protected

The number of currently running threaded readers.

Definition at line 251 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 244 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 263 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 258 of file creaImageIOMultiThreadImageReader.h.

vtkImageData * creaImageIO::MultiThreadImageReader::mRequestedImage

protected

For GetImage : the image requested.

Definition at line 260 of file creaImageIOMultiThreadImageReader.h.

ThreadedImageReaderListType creaImageIO::MultiThreadImageReader::mThreadedImageReaderList

protected

Definition at line 249 of file creaImageIOMultiThreadImageReader.h.

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

long creaImageIO::MultiThreadImageReader::mTotalMem

protected

Definition at line 273 of file creaImageIOMultiThreadImageReader.h.

Referenced by SignalImageRead().

long creaImageIO::MultiThreadImageReader::mTotalMemMax

protected

Definition at line 274 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 270 of file creaImageIOMultiThreadImageReader.h.

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

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

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

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