mlMemoryImage.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_MEMORY_IMAGE_H
#define ML_MEMORY_IMAGE_H
 
 
// ML-includes
#include "mlInitSystemML.h"
#include "mlRuntime.h"
#include "mlRuntimeSubClass.h"
#include "mlSubImage.h"
 
#include <mlMetaProfilePtr.h>
 
 
ML_START_NAMESPACE
 
class MemoryImageCurrentlyUsedMemoryTracker;
class Module;
class PagedImage;
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class ML_UNIX_ONLY_EXPORT(MLEXPORT) MemoryImage
{
 
public:
 
  //------------------------------------------------------
  //------------------------------------------------------
  inline MemoryImage() :
    _subImg(),
    _isValid(false),
    _userControlled(false),
    _calculationPending(false),
    _calculationPendingProcessingScope(-1),
    _currentlyUsedMemoryTracker(nullptr)
  {
  }
 
  MLEXPORT virtual ~MemoryImage();
 
 
  //------------------------------------------------------
  //------------------------------------------------------
  inline SubImage& getImage() { return _subImg;  }
 
  inline const SubImage& getImage() const { return _subImg;  }
 
  inline void setValid(bool valid)
  {
    Lock lock(_mutex);
    _isValid = valid;
  }
 
  inline bool isValid() const                 { Lock lock(_mutex); return _isValid; }
 
  inline MLint getSizeInBytes() const
  {
    return _subImg.getSizeInBytes();
  }
 
  inline void setUserControlled(bool userControlled)
  {
    _userControlled = userControlled;
  }
 
  inline bool isUserControlled() const
  {
    return _userControlled;
  }
 
  inline void setCalculationPending(bool flag, int processingScope = -1)
  {
    Lock lock(_mutex);
    _calculationPending = flag;
    _calculationPendingProcessingScope = processingScope;
  }
 
  inline bool isCalculationPending(int processingScope) const
  {
    Lock lock(_mutex);
    return _calculationPending && (_calculationPendingProcessingScope == processingScope);
  }
 
  MLEXPORT std::string getAsString() const;
 
  MLEXPORT void clear();
 
  //-----------------------------------------------------------------------------
  //-----------------------------------------------------------------------------
  [[nodiscard]]
  MLEXPORT MLErrorCode update(PagedImage* image, const SubImageBox& roi, MLDataType newDataType,
                              MLRequestProgressCB*  progressCallback = nullptr,
                              void*                 progressCallbackUserData = nullptr);
 
  //-----------------------------------------------------------------------------
  //-----------------------------------------------------------------------------
  MLEXPORT void updateWithSubImage(const SubImage& image);
 
  MLEXPORT MLMetaProfilePtr& getMetaProfile() const;
 
private:
  void updateProfilingData();
 
  mutable Mutex _mutex;
 
  SubImage    _subImg;
 
  bool      _isValid;
 
  bool      _userControlled;
 
  bool      _calculationPending;
 
  int       _calculationPendingProcessingScope;
 
  MemoryImageCurrentlyUsedMemoryTracker* _currentlyUsedMemoryTracker;
 
  mutable MLMetaProfilePtr _metaProfilePtr;
 
  friend class MemoryImageCurrentlyUsedMemoryTracker;
 
#if ML_DEPRECATED_SINCE(3,5,0)
 
 
public:
 
  MLEXPORT ML_DEPRECATED MLErrorCode update(Module *op, MLint outIndex, const SubImageBox &roi, MLDataType newDT);
  inline ML_DEPRECATED SubImage& getImg() { return getImage(); }
  inline ML_DEPRECATED const SubImage& getConstImg() const { return getImage(); }
  inline ML_DEPRECATED MLint getMemoryImgSize() const { return getSizeInBytes(); }
  inline MLEXPORT ML_DEPRECATED void clearMemoryImg() { clear(); }
  inline MLEXPORT ML_DEPRECATED void updateWithSubImg(const SubImage& image) { updateWithSubImage(image); }
  inline ML_DEPRECATED void setManualControl(bool flag) { return setUserControlled(flag); }
  inline ML_DEPRECATED bool getManualControl() const { return isUserControlled(); }
 
 
#endif
 
};
 
 
#if ML_DEPRECATED_SINCE(3,5,0)
ML_DEPRECATED typedef MemoryImage MemoryImg;
#endif
 
 
ML_END_NAMESPACE
 
 
 
//-----------------------------------------------------------------------------------
//   Stream output for std::ostream
//-----------------------------------------------------------------------------------
namespace std {
 
  inline ostream& operator<<(ostream& s, const ML_NAMESPACE::MemoryImage &mi)
  {
    return s << mi.getAsString().c_str();
  }
 
}
 
 
#endif