mlVirtualVolume.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_VIRTUAL_VOLUME_H
#define ML_VIRTUAL_VOLUME_H
 
 
 
// Include dll-specific settings.
#include "MLToolsSystem.h"
 
// Include most ml specific things.
#include "mlModuleIncludes.h"
 
#include <mlMemoryManager.h>
 
class MLMemoryProfile;
 
ML_START_NAMESPACE
 
  class VirtualVolume;
  class BitImage;
  struct PageBuffer;
  template<class DATATYPE> class TVirtualVolume;
 
  class VirtualVolumeMemoryTracker;
 
  //--------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------
  class MLTOOLS_EXPORT VirtualVolume{
 
  public:
 
    // ---- Public member functions:
 
    VirtualVolume(PagedImage*  image,
                  MLDataType dType,
                  MLint      maxNumKB = -1,
                  bool       areExceptionsOnFlag = false);
 
    VirtualVolume(const ImageVector &ext            = ImageVector(0),
                  MLdouble      fillVal             = 0,
                  MLDataType    dType               = MLuint8Type,
                  MLint         maxNumKB            = -1,
                  bool          areExceptionsOnFlag = false);
 
    VirtualVolume(const ImageVector &extent, const ImageVector& pageExtent,
                  MLdouble      fillVal = 0,
                  MLDataType    dType = MLuint8Type,
                  MLint         maxNumKB = -1,
                  bool          areExceptionsOnFlag = false);
 
    virtual                    ~VirtualVolume()                 { _reset();                                  }
 
    inline MLint               getDim() const                   { return _dim;                               }
 
    inline const SubImageBox   &getBox() const                  { return _pagedImgBox;                       }
 
    inline ImageVector          getExtent() const               { return _pagedImgBox.getExtent();           }
 
    inline MLDataType           getDataType() const             { return _dataType;                          }
 
    inline Module              *getModule() const               { return _module;                            }
 
    inline PagedImage          *getInputImage() const           { return _pagedImg;                          }
 
    inline MLint                getInputIndex() const           { return _module ? _outIdx : -1;             }
 
    inline bool                 isValid() const                 { return _valid;                             }
 
    inline void                 invalidate()                    { _valid = false; _cleanUpMemory();          }
 
    inline MLuint               getNumMappedPages() const       { return _numMappedPages;                    }
 
    inline MLuint               getNumWrittenPages()            { _updateWrittenPages(); return _numWrittenPages;}
 
    inline MLuint               getNumPages()                   { return _numMappedPages+getNumWrittenPages(); }
 
    inline MLuint               getNumBytes()                   { return getNumPages()*_numPageBytes;        }
 
    inline bool                 areExceptionsOn() const         { return _areExceptionsOn;                   }
 
    inline const ImageVector    &getPageExtent() const          { return _pageExt;                           }
 
    inline const ImageVector    &getPageArrayExtent() const     { return _pageArrayExt;                      }
 
    inline const SubImageBox &getWrittenPageBox(MLuint32 wp);
 
    void                   *getWrittenPageData(MLuint32 wp);
 
    void                   unMapAndClearWrittenPages();
 
    enum PageMapped { IsMapped, IsUnMapped };
 
    typedef void (*PageFunc) (VirtualVolume *obj, PageBuffer *page, PageMapped mapped, void *userData);
 
    void registerPageFunction(PageFunc pFunc, void *userData);
 
    void resize(const ImageVector &newExt);
 
    void copyTileFromInputImage(const SubImageBox      &box,
                                PagedImage             &image,
                                const ImageVector         &shift,
                                const ScaleShiftData &scaleShift=ScaleShiftData());
 
 
    void copyToSubImage(SubImage &outSubImg);
 
#if 0
    // Copy area from inImg into virtual volume. This non-template version is still
    // not implemented but desirable. Only valid areas are copied; regions outside
    // input or virtual volume areas are not handled.
    // Errors are reported by thrown exceptions if exception handling is enabled;
    // otherwise they lead to ML_PRINT_ERROR or ML_PRINT_FATAL_ERROR messages.
    // Only valid regions of the virtual volume are written; box is clipped against
    // the virtual volume extents before writing the data region.
    void copyFromSubImg(const SubImage    &inImg,
                        const SubImageBox &box,
                        const ImageVector    &pos);
#endif
 
    BitImage *getUsedPagesMask(bool enableMappedPages=true,
                               bool enableWrittenPages=true) const;
 
    void *createTypedVirtualVolume();
 
    static void destroyTypedVirtualVolume(void *tVV, MLDataType dt);
 
#if ML_DEPRECATED_SINCE(3,5,0)
 
 
public:
  inline ML_DEPRECATED ImageVector getExt() const                     { return getExtent();                       }
 
  ML_DEPRECATED BaseOp* getBaseOp() const;
 
  inline ML_DEPRECATED PagedImage* getInImg() const                   { return _pagedImg;                          }
 
  inline ML_DEPRECATED MLint getInIdx() const                         { return _module ? _outIdx : -1;             }
 
  inline ML_DEPRECATED const ImageVector& getPageExt() const          { return _pageExt;                           }
 
  inline ML_DEPRECATED const ImageVector& getPageArrayExt() const     { return _pageArrayExt;                      }
 
  inline ML_DEPRECATED void copyTileFromInImg(const SubImageBox      &box,
                           PagedImage             &image,
                           const ImageVector         &shift,
                           const ScaleShiftData &scaleShift=ScaleShiftData()) { copyTileFromInputImage(box, image, shift, scaleShift); }
 
  inline ML_DEPRECATED void copyToSubImg(SubImage &outSubImg) { copyToSubImage(outSubImg); }
 
  ML_DEPRECATED_CONSTRUCTOR VirtualVolume(Module    *baseOp,
      MLint      connIdx,
      MLDataType dType,
      MLint      maxNumKB = -1,
      bool       areExceptionsOnFlag = false,
      bool       useOutConnectors    = false);
 
  ML_DEPRECATED void copyTileFromInImg(const SubImageBox      &box,
      Module               &op,
      MLint                 outIdx,
      const ImageVector         &shift,
      const ScaleShiftData &scaleShift=ScaleShiftData());
 
 
#endif
 
  protected:
 
    void                   _init(PagedImage     *img,
                                 const ImageVector &ext,
                                 const ImageVector &pageExtent,
                                 MLdouble      fillVal,
                                 MLDataType    dType,
                                 MLint         maxNumKB = -1,
                                 bool          areExceptionsOnFlag = false);
 
    void                   _reset();
 
    void                   _cleanUpMemory();
 
 
 
    // ---- Protected member functions:
 
    template<typename> friend class TVirtualVolume;
 
    void                _default();
 
    inline static void* _getPageCB(PageBuffer *pageBuffer);
 
    static void*        _loadPageCB(PageBuffer *pageBuffer);
 
    void*               _loadPage(PageBuffer *pageBuffer);
 
    void                _updateWrittenPages();
 
    PageBuffer         *_getPageBuffer6D(const ImageVector &pos);
 
  private:
 
    MLuint              _makePowerOfTwo(MLint &num) const;
 
    MLint                _getPowerOfTwo(MLuint        num) const;
 
    MLMemoryProfile* _getMemoryProfile();
 
 
    // ---- Members:
 
 
 
    bool            _valid;
 
    Module         *_module;
 
    MLint32         _outIdx;
 
    PagedImage     *_pagedImg;
 
    SubImageBox     _pagedImgBox;
 
    ImageVector     _origVolumeExt;
 
    ImageVector     _pageExt;
 
    MLint           _maxNumKB;
 
    MLDataType      _dataType;
 
    MLdouble        _fillValue;
 
    bool            _areExceptionsOn;
 
    PageFunc        _pageFunc;
 
    void           *_pageFuncData;
 
 
    MLuint          _numPageBytes;
 
    ImageVector     _volumeExt;
 
    MLint           _dim;
 
    ImageVector     _pageArrayExt;
 
    MLuint          _numPageArrayEntries;
 
    MLuint          _maxMappedPages;
 
 
    ImageVector     _strides;
 
    ImageVector     _pStrides;
 
    ImageVector     _rShift;
 
    ImageVector     _idxMask;
 
 
    PageBuffer     *_pageArray;
 
    PageBuffer    **_mappedPages;
 
    MLuint          _numMappedPages;
 
    PageBuffer    **_writtenPages;
 
    MLuint          _numWrittenPages;
 
    MLuint          _nextThrowPage;
 
    VirtualVolumeMemoryTracker* _currentlyUsedMemoryTracker;
 
    friend class VirtualVolumeMemoryTracker;
  };
 
  //--------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------
  struct MLTOOLS_EXPORT PageBuffer {
 
    typedef void *(*ReturnPageFunc)(PageBuffer *toMePtr);
 
    inline PageBuffer(): _virtVol(nullptr), _page(nullptr), _locked(false), _getPageFkt(nullptr) { }
 
    VirtualVolume *_virtVol;
 
    SubImageBox    _box;
 
    MLMemoryBlockHandle _memoryBlockHandle;
 
    void          *_page;
 
    bool           _locked;
 
    ReturnPageFunc _getPageFkt;
  };
 
  inline void* VirtualVolume::_getPageCB(PageBuffer *pageBuffer) { return pageBuffer->_page; }
 
ML_END_NAMESPACE
 
// For compatibilities we include the TVirtualVolume here.
#include "mlTVirtualVolume.h"
 
#endif // __mlVirtualVolume_H