mlModule.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_MODULE_H
#define ML_MODULE_H
 
 
// ML-includes
#include "mlInitSystemML.h"
#include "mlRuntimeSubClass.h"
#include "mlBase.h"
#include "mlFields.h"
#include "mlFieldContainer.h"
 
#include "mlModuleInterfaces.h"
#include "mlProcessAllPagesHandler.h"
#include "mlPagedImage.h"
 
#include <mlMetaProfilePtr.h>
 
 
#define ML_ADD_FIELD(NAME_P, TYPE_P, VALUE_P) \
(static_cast<TYPE_P##Field*> (this->addField(NAME_P, #TYPE_P, VALUE_P)));
 
class MLMemoryBlockHandle;
 
// Namespace ML. It is recommended that all ML classes and modules reside in this
// namespace to avoid collisions with types of other libraries.
ML_START_NAMESPACE
 
// ML-classes
class SubImage;
class PagedImage;
class ProcessAllPagesHandler;
 
//-------------------------------------------------------------------------
 
//-------------------------------------------------------------------------
class MLEXPORT Module : public FieldContainer
{
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  friend class Host;
  friend class PagedImage;
  friend class PageRequest;
  friend class TileRequest;
  friend class ModuleCalculateOutputImageHandler;
  friend class State;
  friend class ClassicHost;
 
  ML_DISALLOW_COPY_AND_ASSIGN(Module)
 
public:
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
 
public: Module(int numInputImages, int numOutputImages);
 
public: ~Module() override;
 
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
 
protected: void setOutputImageInplace(MLint outputIndex=0, MLint inputIndex=0);
 
protected: void unsetOutputImageInplace(MLint outputIndex=0);
 
public:    MLint getOutputImageInplace(MLint outputIndex=0) const;
 
 
 
protected: void setBypass(MLint outputIndex=0, MLint inputIndex=0);
 
public:    MLint getBypass(MLint outputIndex=0) const;
 
protected: void setClampPagesToImageExtent(bool flag = true);
 
  enum THREAD_SUPPORT {
    NO_THREAD_SUPPORT = PagedImage::NO_THREAD_SUPPORT, 
    MULTITHREADED     = PagedImage::MULTITHREADED,     
    IO_THREAD         = PagedImage::IO_THREAD,         
  };
 
protected: void setThreadSupport(THREAD_SUPPORT supportMode);
 
public:    THREAD_SUPPORT getThreadSupport() const;
 
 
protected: void permitRecursiveHandleNotifications(bool enable);
 
public:    bool areRecursiveHandleNotificationsPermitted() const;
 
public:    MLint getHandleNotificationEntryCounter() const;
 
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
public: enum PERMITTED_TYPES {
  ONLY_SCALAR_TYPES,
  ONLY_DEFAULT_TYPES,
  ALL_REGISTERED_TYPES,
};
 
protected: void setVoxelDataTypeSupport(PERMITTED_TYPES permTypes);
 
public:    PERMITTED_TYPES getVoxelDataTypeSupport() const;
 
public:    bool isSupportedVoxelDataType(MLDataType dt) const;
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
 
public:    enum INPUT_STATE  {
  DISCONNECTED = 0, //<! Defines that the input is disconnected. In the case of handleInput, this means that the input image cannot be updated to a valid image.
  CONNECTED_BUT_INVALID      = 1,  //<! Defines that the input is connected but has no valid data.
  CONNECTED_AND_VALID        = 2,  //<! Defines that the input is connected and valid.
  CONNECTED_BUT_NEEDS_UPDATE = 3,  //<! Defines that the input is connected and needs to be updated via updateImageProperties(). After the update, it may either become CONNECTED_AND_VALID or CONNECTED_BUT_INVALID.
};
 
public:    enum INPUT_HANDLE {
  INVALIDATE                = 0, //<! Used as return value of handleInput() to indicate that the given input is not allowed to be invalid and the output images of the module should be invalidated without calling calculateOutputImageProperties().
  ALLOW_INVALID_INPUT       = 2, //<! Used as return value of handleInput() to indicate that the given input is allowed to be invalid. calculateOutputImageProperties() will be called and getInputImage() for that input index will return NULL.
};
 
public:    virtual INPUT_HANDLE handleInput(int /*inputIndex*/, INPUT_STATE /*state*/) const { return INVALIDATE; }
 
public:    INPUT_STATE getInputState(MLint index);
 
public:    INPUT_STATE getUpdatedInputState(MLint index);
 
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
 
public:
  InputConnectorField*  getInputImageField(MLint i) const;
  OutputConnectorField* getOutputImageField(MLint i=0) const;
 
  MLint getNumInputImages() const;
 
  MLint getNumOutputImages() const;
 
  PagedImage* getOutputImage(MLint outputIndex=0) const;
 
  InputConnectorField* addInputImage(const char* name = nullptr);
 
  OutputConnectorField* addOutputImage(const char* name = nullptr);
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
public:    PagedImage* getInputImage(MLint inputIndex, bool getReal=false) const;
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
public:    PagedImage *getUpdatedInputImage(MLint inputIndex, bool getReal=false) const;
 
 
 
 
  //---------------------------------------------------------------------------
  //         These functions are identical to those from
  //         Host::getDefaultHost() and are
  //         wrapped here for convenience.
  //         See mlHost.h for documentation.
  //---------------------------------------------------------------------------
public:
 
  [[nodiscard]]
  static MLErrorCode getTile(PagedImage*  image,
                             SubImageBox  loc,
                             MLDataType datatype,
                             void**     data,
                             const ScaleShiftData &scaleShiftData=ScaleShiftData(),
                             MLRequestProgressCB* progressCallback = nullptr,
                             void*                progressCallbackUserData = nullptr);
 
  [[nodiscard]]
  static MLErrorCode getTile(PagedImage* image,
                             SubImage &subimg,
                             const ScaleShiftData &scaleShiftData = ScaleShiftData(),
                             MLRequestProgressCB*  progressCallback = nullptr,
                             void*                 progressCallbackUserData = nullptr);
 
  static MLErrorCode updateImageProperties(PagedImage* image);
 
  static void        freeTile(void* data);
 
  static void        updateProgress(const char* info1, const char* info2);
 
  static bool        shouldTerminate();
 
  static Field*      getPressedNotifyField();
 
  static void adaptPageExtent (ImageVector&       pageExtent,
                               MLDataType         imageType,
                               const ImageVector& newImgExtent,
                               const ImageVector& oldImgExtent,
                               const ImageVector& pageUnit      = ImageVector(0),
                               const ImageVector& minPageExtent = ImageVector(0),
                               const ImageVector& maxPageExtent = ImageVector(0));
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
 
  static std::string getVoxelValueAsString(PagedImage*          image,
                                           const ImageVector& position,
                                           MLErrorCode*       errorCode=nullptr,
                                           const std::string& errorResult="");
 
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
 
protected: virtual CalculateOutputImageHandler* createCalculateOutputImageHandler(PagedImage* outputImage);
 
protected:
  virtual void calculateOutputImageProperties([[maybe_unused]] int outputIndex, [[maybe_unused]] PagedImage* outputImage) {}
 
protected:
  virtual SubImageBox calculateInputSubImageBox(int /*inputIndex*/,
                                                       const SubImageBox& outputSubImageBox,
                                                       int /*outputIndex*/)
  {
    return outputSubImageBox;
  };
 
protected: virtual void calculateOutputSubImage(SubImage *outputSubImage, int outputIndex, SubImage *inputSubImages);
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
 
protected: virtual void provideCustomPage(int /*outputIndex*/, const SubImageBox& /*pageBox*/, MLMemoryBlockHandle& /*resultPage*/) {};
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
public:
  [[nodiscard]]
  MLErrorCode processAllPages(int       outputIndex = -1,
                                    SubImageBox region = SubImageBox(),
                                    MLRequestProgressCB* progressCallback = nullptr,
                                    void* progressCallbackUserData = nullptr);
 
public:
  [[nodiscard]]
  MLErrorCode processAllPages(ProcessAllPagesHandler& handler,
                                    SubImageBox region  = SubImageBox(),
                                    MLRequestProgressCB* progressCallback = nullptr,
                                    void* progressCallbackUserData = nullptr);
 
public:
  [[nodiscard]]
  MLErrorCode processMissingPages(int outputIndex = 0,
                                        SubImageBox region  = SubImageBox(),
                                        MLRequestProgressCB* progressCallback = nullptr,
                                        void* progressCallbackUserData = nullptr);
 
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
 
public:    void clearOutputImage(MLint i=0);
 
public: MLMetaProfilePtr& getMetaProfile() const;
 
 
 
public:
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
protected: void handleNotificationOff();
 
protected: void handleNotificationOn();
 
protected: bool isHandleNotificationOn();
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
 
public:    bool isInputImageField(Field* field) const;
 
public:    void touchOutputImageFields() const;
 
protected: virtual void handleNotification(Field* /*field*/) {}
 
public:    virtual void beginSaveFields() {}
 
public:    virtual void endSaveFields() {}
 
protected: void handleNotificationInternal(Field* field, FieldSensor::Strength strength) override;
 
 
  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
public:    static size_t getNumModules();
 
public:    static Module* getModule(size_t index);
 
public:    static MLint findModuleIndex(Module& module);
 
public:    static void destroyModule();
 
 
private:   void setWasVisited(bool flag) { _visitedFlag = flag;  }
 
private:   bool wasVisited()             { return _visitedFlag; }
 
 
private:
  //-----------Private methods:
  bool _addBaseOp(Module& module);
 
  MLint _removeBaseOp(Module& module);
 
 
  //-----------Private members:
  std::vector <OutputConnectorField*> _outputConnectorFields;
 
  std::vector <InputConnectorField*>  _inputConnectorFields;
 
  THREAD_SUPPORT         _threadSupport;
 
  MLint                  _handleNotificationEntryCounter;
 
  bool                   _permitRecursiveHandleNotifications;
 
  bool                   _visitedFlag;
 
  PERMITTED_TYPES        _permittedTypes;
 
  MLint                  _handleNotificationBlockCounter;
 
  mutable MLMetaProfilePtr _metaProfilePtr;
 
  static std::vector<Module*> _instantiatedModules;
 
  ML_ABSTRACT_CLASS_HEADER(Module)
 
public:
 
  const char* getTypeNameFast() const { return getTypeId() ? getTypeId()->getName() : "<unregistered_module>"; }
 
};
 
class MLEXPORT ModuleDiagnosisStackScope
{
public:
  ModuleDiagnosisStackScope(Module* module) : _module(module) { if (pushModuleForDiagnosis) { pushModuleForDiagnosis(_module); } }
  ~ModuleDiagnosisStackScope() { if (popModuleForDiagnosis) { popModuleForDiagnosis(_module); } }
 
  typedef void (*DiagnosisModuleStackCallback)(void*);
 
  static void setCallbacksForDiagnosisModuleStack(DiagnosisModuleStackCallback pushCallback, DiagnosisModuleStackCallback popCallback)
  {
    pushModuleForDiagnosis = pushCallback;
    popModuleForDiagnosis = popCallback;
  }
 
private:
  static DiagnosisModuleStackCallback pushModuleForDiagnosis;
  static DiagnosisModuleStackCallback popModuleForDiagnosis;
 
  Module* _module;
};
 
ML_END_NAMESPACE
 
#endif