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;
};
 
 
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