MeVis/Foundation/Sources/ML/include/mlHost.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
#ifndef __mlHost_H
#define __mlHost_H

//ML-includes
#ifndef __mlInitSystemML_H
#include "mlInitSystemML.h"
#endif
#ifndef __mlBasics_H
#include "mlBasics.h"
#endif
#ifndef __mlPagedImage_H
#include "mlPagedImage.h"
#endif
#ifndef __mlSubImage_H
#include "mlSubImage.h"
#endif
#ifndef __mlFields_H
#include "mlFields.h"
#endif
#ifndef __mlWaitCondition_H
#include "mlWaitCondition.h"
#endif
#ifndef __mlThread_H
#include "mlThread.h"
#endif

ML_START_NAMESPACE

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

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
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();

  static MLErrorCode  pushDefaultHost();

  static MLErrorCode  popDefaultHost();

  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:
  //------------------------------------------------------

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

  MLErrorCode getTile(PagedImage&             outputImage,
                      SubImageBox             location,
                      MLDataType            dataType,
                      void**                data,
                      const ScaleShiftData& scaleShiftData=ScaleShiftData()) ML_RETURN_VALUE_SHOULD_BE_USED;


  MLErrorCode getTile(PagedImage&             outputImage,
                      SubImage&               subImage,
                      const ScaleShiftData& scaleShiftData=ScaleShiftData()) ML_RETURN_VALUE_SHOULD_BE_USED;

  void freeTile(void* data);

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

  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  MLErrorCode processAllPages(Module& module,
                              MLint     outputIndex,
                              SubImageBox region=SubImageBox()) ML_RETURN_VALUE_SHOULD_BE_USED;

  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  MLErrorCode processAllPages(Module&               module,
                              ProcessAllPagesHandler& handler,
                              SubImageBox               region=SubImageBox()) ML_RETURN_VALUE_SHOULD_BE_USED;

  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  MLErrorCode processMissingPages(Module& module, MLint outputIndex, SubImageBox region=SubImageBox()) ML_RETURN_VALUE_SHOULD_BE_USED;


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

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

  MLErrorCode updateImageProperties(Module &module, MLint outputIndex) ML_RETURN_VALUE_SHOULD_BE_USED;

  MLErrorCode updateImageProperties(PagedImage& outputImage) ML_RETURN_VALUE_SHOULD_BE_USED;

  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);
  
#ifdef ML_DEPRECATED


  
public:

  ML_DEPRECATED MLErrorCode getTile(Module                &op,
                                    MLint                  outIndex,
                                    SubImageBox              loc,
                                    MLDataType             dataType,
                                    void                 **data,
                                    const ScaleShiftData  &scaleShiftData=ScaleShiftData()) ML_RETURN_VALUE_SHOULD_BE_USED;
  ML_DEPRECATED MLErrorCode getTile(Module               &op,
                                    MLint                 outIndex,
                                    SubImage               &subImg,
                                    const ScaleShiftData &scaleShiftData=ScaleShiftData()) ML_RETURN_VALUE_SHOULD_BE_USED;
  inline ML_DEPRECATED MLErrorCode updateImageProps(Module &op, MLint outIndex) ML_RETURN_VALUE_SHOULD_BE_USED { 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 // ML_DEPRECATED


private:
  ML_DISALLOW_COPY_AND_ASSIGN(Host)

  // ------------------------------------------------------------------------------
  // ------------------------------------------------------------------------------
  MLErrorCode _processAllPages(Module&  module,
                               MLint      outputIndex,
                               SubImageBox  region,
                               ProcessAllPagesHandler* handler,
                               bool clearPages = true
                               ) ML_RETURN_VALUE_SHOULD_BE_USED;

  MLErrorCode _requiredTypesRegisteredAndSupported(PagedImage* outputImage);

  MLErrorCode _updateImageProperties(PagedImage* outputImage) ML_RETURN_VALUE_SHOULD_BE_USED;

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

  //------------------------------------------------------
  void*              _userData;

  MLHostProgressCB*  _progressCB;

  void*              _breakCheckUserData;

  MLHostBreakCheckCB* _breakCheckCB;

  MLint32            _maxNumThreads;

  MLint32            _restrictMaxNumThreads;

  MLuint32           _isProcessingActive;

  static unsigned int         _memoryManagerId;

  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