MeVisLab/Standard/Sources/ML/MLTools/include/mlVirtualVolume.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
#ifndef __mlVirtualVolume_H
#define __mlVirtualVolume_H

// Include dll-specific settings.
#ifndef __MLToolsSystem_H
#include "MLToolsSystem.h"
#endif

// Include most ml specific things.
#ifndef __mlModuleIncludes_H
#include "mlModuleIncludes.h"
#endif

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

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

#ifdef ML_DEPRECATED



#ifdef WIN32
#pragma warning(push)
#pragma warning(disable : 4996 )
#endif

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

#ifdef WIN32
#pragma warning(pop)
#endif

#endif // ML_DEPRECATED

  protected:

    void                   _init(PagedImage     *img,
                                 const ImageVector &ext,
                                 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;

    long                _getPowerOfTwo(MLuint        num) const;
    
    MLMemoryProfile* _getMemoryProfile();
    

    // ---- Members:




    bool            _valid;

    Module         *_module;

    MLint32         _outIdx;

    PagedImage     *_pagedImg;

    SubImageBox     _pagedImgBox;

    ImageVector     _origVolumeExt;

    ImageVector     _pageExt;

    long            _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;

    ML_CLASS_HEADER(VirtualVolume);
    
    friend class VirtualVolumeMemoryTracker;
  };

  //--------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------
  struct MLTOOLS_EXPORT PageBuffer {

    typedef void *(*ReturnPageFunc)(PageBuffer *toMePtr);

    inline PageBuffer(): _virtVol(NULL), _page(NULL), _locked(false), _getPageFkt(NULL) { }

    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.
#ifndef __mlTVirtualVolume_H
#include "mlTVirtualVolume.h"
#endif

#endif // __mlVirtualVolume_H