mlHost.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_HOST_H
#define ML_HOST_H

 
//ML-includes
#include "mlInitSystemML.h"
#include "mlPagedImage.h"
#include "mlSubImage.h"
#include "mlFields.h"
#include "mlWaitCondition.h"
#include "mlThread.h"
 
ML_START_NAMESPACE

class Module;
class ThreadDataClass;
class ProcessAllPagesHandler;
class ClassicHost;
class PageRequestProcessorBase;
class PageRequestProcessor;
class ProcessingTimeLine;
class GetTileJobBase;

#define ML_HOST_UPDATE_PROGRESS_INTERVAL 0.3
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Host
{
 
public:
 
  friend class PageRequestProcessor;
  friend class SingleThreadedPageRequestProcessor;
  friend class MultiThreadedPageRequestProcessor;
  friend class ClassicHost;
 
  //------------------------------------------------------
  //------------------------------------------------------
  static void registerWithMemoryManager();

  Host();

  virtual ~Host();
 
  //--- Progress Callback
  void                setProgressCB(void *userData, MLHostProgressCB *callback);

  MLHostProgressCB   *getProgressCB() const;

  void               *getProgressCBUserData() const;

  void                updateProgress(const char* info1, const char* info2);
 
  //--- Break check callback
  void                setBreakCheckCB(void *userData, MLHostBreakCheckCB *callback);

  MLHostBreakCheckCB *getBreakCheckCB() const;

  void               *getBreakCheckCBUserData() const;
 

  bool                shouldTerminate() const;

  Field               *getPressedNotifyField();

  static Host         &getDefaultHost();

  static void         destroyDefaultHost();

  void                setMaxNumThreads(MLint32 numThreads);

  MLint32             getMaxNumThreads() const;

  void                setRestrictMaxNumThreads(MLint32 numThreads);

  MLint32             getRestrictMaxNumThreads() const { return _restrictMaxNumThreads; }

  MLuint32            isProcessingActive() const;
 
protected:
  void _setProcessingActive();

  void _unsetProcessingActive();
 
public:
  //------------------------------------------------------
  //------------------------------------------------------

  [[nodiscard]]
  MLErrorCode getTile(PagedImage&           outputImage,
                      SubImageBox           location,
                      MLDataType            dataType,
                      void**                data,
                      const ScaleShiftData& scaleShiftData = ScaleShiftData(),
                      MLRequestProgressCB*  progressCallback = nullptr,
                      void*                 progressCallbackUserData = nullptr);

  [[nodiscard]]
  MLErrorCode getTile(PagedImage&           outputImage,
                      SubImage&             subImage,
                      const ScaleShiftData& scaleShiftData = ScaleShiftData(),
                      MLRequestProgressCB*  progressCallback = nullptr,
                      void*                 progressCallbackUserData = nullptr);

  void freeTile(void* data);
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  [[nodiscard]]
  MLErrorCode processAllPages(Module& module,
                              MLint     outputIndex,
                              SubImageBox region = SubImageBox(),
                              MLRequestProgressCB* progressCallback = nullptr,
                              void* progressCallbackUserData = nullptr);
 
  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  [[nodiscard]]
  MLErrorCode processAllPages(Module&               module,
                              ProcessAllPagesHandler& handler,
                              SubImageBox           region=SubImageBox(),
                              MLRequestProgressCB* progressCallback = nullptr,
                              void* progressCallbackUserData = nullptr);
 
  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  [[nodiscard]]
  MLErrorCode processMissingPages(Module& module, MLint outputIndex, SubImageBox region=SubImageBox(),
                                  MLRequestProgressCB* progressCallback = nullptr,
                                  void* progressCallbackUserData = nullptr);
 
 
  //-------------------------------------------------------------------------------------------------
  [[nodiscard]]
  MLErrorCode processAllPagesWithInputImage(PagedImage& inputImage, ProcessAllPagesHandler& handler, const SubImageBox& region= SubImageBox(),
                                            MLRequestProgressCB* progressCallback = nullptr,
                                            void* progressCallbackUserData = nullptr);
 
  //-------------------------------------------------------------------------------------------------
  [[nodiscard]]
  MLErrorCode processAllPagesWithInputImages(const std::vector<PagedImage*>& inputImages, ProcessAllPagesHandler& handler, const SubImageBox& region= SubImageBox(),
                                             MLRequestProgressCB* progressCallback = nullptr,
                                             void* progressCallbackUserData = nullptr);

 
  //------------------------------------------------------
  //------------------------------------------------------

  [[nodiscard]]
  MLErrorCode updateImageProperties(Module &module, MLint outputIndex);

  [[nodiscard]]
  MLErrorCode updateImageProperties(PagedImage& outputImage);

  static inline unsigned int getMemoryManagerId() { return _memoryManagerId; }

  static SubImageBox calculateInputSubImageBoxDebug(Module& module, int inIndex, const SubImageBox& outputSubImageBox, int outputIndex);

  ClassicHost* getClassicHostDebug() { return _classicHost; }

  void setUseClassicHost(bool flag);

  bool getUseClassicHost() const  { return _useClassicMLHost; }

  PageRequestProcessor* getPageRequestProcessor();

  ProcessingTimeLine& getProcessingTimeLine();

  void enableTimeLineProfiling(bool flag);
 
private:
  ML_DISALLOW_COPY_AND_ASSIGN(Host)
 
  // ------------------------------------------------------------------------------
  // ------------------------------------------------------------------------------
  [[nodiscard]]
  MLErrorCode _processAllPages(Module&  module,
                               MLint      outputIndex,
                               SubImageBox  region,
                               ProcessAllPagesHandler* handler,
                               bool clearPages = true,
                               MLRequestProgressCB* progressCallback = nullptr,
                               void* progressCallbackUserData = nullptr);

  MLErrorCode _requiredTypesRegisteredAndSupported(PagedImage* outputImage);

  [[nodiscard]]
  MLErrorCode _updateImageProperties(PagedImage* outputImage);

  bool tryDirectCacheAccess(PagedImage& inImage, const SubImageBox& box, MLDataType dataType, const ScaleShiftData& scaleShiftData, void** data, MLErrorCode& resultCode);
 
  //------------------------------------------------------
  //------------------------------------------------------
  void*              _userData;

  MLHostProgressCB*  _progressCB;

  bool _insideUpdateProgress;

  GetTileJobBase*    _currentTopLevelRequest;

  void*              _breakCheckUserData;

  MLHostBreakCheckCB* _breakCheckCB;

  MLint32            _maxNumThreads;

  MLint32            _restrictMaxNumThreads;

  MLuint32           _isProcessingActive;

  static unsigned int         _memoryManagerId;

  static Host* _instance;

  ClassicHost* _classicHost;

  PageRequestProcessorBase* _processor;
 
  bool _useClassicMLHost;

 
}; //End of class Host
 
ML_END_NAMESPACE
 
//-----------------------------------------------------------------------------------
//   Stream output for std::ostream
//-----------------------------------------------------------------------------------
namespace std {

  MLEXPORT ostream& operator<<(ostream& s, const ML_NAMESPACE::Host &host);
 
}
 
#endif //of __mlHost_H