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

    BitImage *getUsedPagesMask(bool enableMappedPages=true,
                               bool enableWrittenPages=true) const;

    void *createTypedVirtualVolume();

    static void destroyTypedVirtualVolume(void *tVV, MLDataType dt);
 
  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