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);
 
#if ML_DEPRECATED_SINCE(3,5,0)
 
 
public:
 
  [[nodiscard]]
  ML_DEPRECATED MLErrorCode getTile(Module                &op,
                                    MLint                  outIndex,
                                    SubImageBox              loc,
                                    MLDataType             dataType,
                                    void                 **data,
                                    const ScaleShiftData  &scaleShiftData=ScaleShiftData());
  [[nodiscard]]
  ML_DEPRECATED MLErrorCode getTile(Module               &op,
                                    MLint                 outIndex,
                                    SubImage               &subImg,
                                    const ScaleShiftData &scaleShiftData=ScaleShiftData());
  [[nodiscard]]
  inline ML_DEPRECATED MLErrorCode updateImageProps(Module &op, MLint outIndex) { return updateImageProperties(op, outIndex); }
 
  inline static ML_DEPRECATED SubImageBox calcInSubImageBoxDebug(Module& module,
                                                               int inIndex,
                                                               const SubImageBox& outSubImgBox,
                                                               int outIndex)
  {
    return calculateInputSubImageBoxDebug(module, inIndex, outSubImgBox, outIndex);
  }
 
#endif
 
 
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;
 
#ifdef MACOS
  // Actual type is: os_log_t
  void* _splog;
#endif
 
 
}; //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