SoVirtualVolume.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 SO_VIRTUAL_VOLUME_H
#define SO_VIRTUAL_VOLUME_H
 

 
#include "SoVirtualVolumeSystem.h"
 
// Incomplete types needed for abstract interface creation.
 
ML_START_NAMESPACE
  class Module;
  template <typename intT> class TVector6DBase;
  template<class TVectorBase> class TVector;
  template <typename intT> class TImageVector;
  typedef TImageVector<MLint> ImageVector;
  class VirtualVolume;
  template<typename DATATYPE> class TVirtualVolume;
ML_END_NAMESPACE
 
//---------------------------------------------------------------------------------
//---------------------------------------------------------------------------------
class SoVirtualVolume
{
public:
  SO_VIRTUALVOLUME_EXPORT SoVirtualVolume(SoSFMLImage &image,
                                          MLDataType dType   = ML_INVALID_DATA_TYPE,
                                          long maxNumKB      = -1,
                                          bool useExceptions = false);

  SO_VIRTUALVOLUME_EXPORT SoVirtualVolume(const XVImageSize &ext           = XVImageSize(0),
                                          double             fillVal       = 0,
                                          MLDataType         dType         = MLuint8Type,
                                          long               maxNumKB      = -1,
                                          bool               useExceptions = false);

  SO_VIRTUALVOLUME_EXPORT virtual ~SoVirtualVolume();

  SO_VIRTUALVOLUME_EXPORT bool                   isValid() const;

  SO_VIRTUALVOLUME_EXPORT SoSFMLImage           *getImage() const;

  SO_VIRTUALVOLUME_EXPORT MLDataType             getDataType() const;

  inline                  long                   getMaxNumKB() const      { return _constructorMaxNumKB; }

  inline                  bool                   areExceptionsOn() const  { return _constructorAreExceptionsOn; }
 
  //---------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------
  SO_VIRTUALVOLUME_EXPORT MLuint          getNumMappedPages() const;

  SO_VIRTUALVOLUME_EXPORT MLuint          getNumWrittenPages();

  SO_VIRTUALVOLUME_EXPORT MLuint          getNumPages() const;

  SO_VIRTUALVOLUME_EXPORT MLuint          getNumBytes() const;

  SO_VIRTUALVOLUME_EXPORT XVImageSize            getPageExtent() const;

  SO_VIRTUALVOLUME_EXPORT XVImageSize            getPageArrayExtent() const;

  SO_VIRTUALVOLUME_EXPORT void                  *getWrittenPageData(MLuint32 wp);

  SO_VIRTUALVOLUME_EXPORT void                   unMapAndClearWrittenPages();

  SO_VIRTUALVOLUME_EXPORT void                   resize(const XVImageSize &newExt);
 
 
  //---------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------
  // DO NOT TRACE: All methods are very time critical!
  inline const XVImageSize &getCursorPosition()                                                          { return reinterpret_cast<const XVImageSize&>(_getCursorPosWFunc(_tVirtualVolume)); }
  inline MLint     getIntValue          (const XVImageSize &pos)                                         { return _getIntVoxelWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(pos)); }
  inline MLint64   getInt64Value        (const XVImageSize &pos)                                         { return _getInt64VoxelWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(pos)); }
  inline MLdouble  getDoubleValue       (const XVImageSize &pos)                                         { return _getDoubleVoxelWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(pos)); }
  inline MLldouble getLDoubleValue      (const XVImageSize &pos)                                         { return _getLDoubleVoxelWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(pos)); }
  inline MLint     getIntCursorValue    ()                                                               { return _getIntCursorVoxelWFunc(_tVirtualVolume); }
  inline MLint64   getInt64CursorValue  ()                                                               { return _getInt64CursorVoxelWFunc(_tVirtualVolume); }
  inline MLdouble  getDoubleCursorValue ()                                                               { return _getDoubleCursorVoxelWFunc(_tVirtualVolume); }
  inline MLldouble getLDoubleCursorValue()                                                               { return _getLDoubleCursorVoxelWFunc(_tVirtualVolume); }
  inline bool      isMapped             (const XVImageSize &pos)                                         { return _isMappedWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(pos)); }
  inline void      setCursorPosition    (const XVImageSize &pos)                                         { _setCursorPosWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(pos)); }
  inline void      setIntValue          (const XVImageSize &pos, MLint     v)                            { _setIntVoxelWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(pos), v); }
  inline void      setInt64Value        (const XVImageSize &pos, MLint64   v)                            { _setInt64VoxelWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(pos), v); }
  inline void      setDoubleValue       (const XVImageSize &pos, MLdouble  v)                            { _setDoubleVoxelWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(pos), v); }
  inline void      setLDoubleValue      (const XVImageSize &pos, MLldouble v)                            { _setLDoubleVoxelWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(pos), v); }
  inline void      setIntCursorValue    (MLint     v)                                                    { _setIntCursorVoxelWFunc(_tVirtualVolume, v); }
  inline void      setInt64CursorValue  (MLint64   v)                                                    { _setInt64CursorVoxelWFunc(_tVirtualVolume, v); }
  inline void      setDoubleCursorValue (MLdouble  v)                                                    { _setDoubleCursorVoxelWFunc(_tVirtualVolume, v); }
  inline void      setLDoubleCursorValue(MLldouble v)                                                    { _setLDoubleCursorVoxelWFunc(_tVirtualVolume, v); }
  inline void      fillInt              (const XVImageSize &boxV1, const XVImageSize &boxV2, MLint     v){ _fillIntWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(boxV1), reinterpret_cast<const ML_NAMESPACE::ImageVector&>(boxV2), v); }
  inline void      fillInt64            (const XVImageSize &boxV1, const XVImageSize &boxV2, MLint64   v){ _fillInt64WFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(boxV1), reinterpret_cast<const ML_NAMESPACE::ImageVector&>(boxV2), v); }
  inline void      fillDouble           (const XVImageSize &boxV1, const XVImageSize &boxV2, MLdouble  v){ _fillDoubleWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(boxV1), reinterpret_cast<const ML_NAMESPACE::ImageVector&>(boxV2), v); }
  inline void      fillLDouble          (const XVImageSize &boxV1, const XVImageSize &boxV2, MLldouble v){ _fillLDoubleWFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(boxV1), reinterpret_cast<const ML_NAMESPACE::ImageVector&>(boxV2), v); }
  inline void      moveCursorX          ()                                                               { _moveFXWFunc(_tVirtualVolume); }
  inline void      moveCursorY          ()                                                               { _moveFYWFunc(_tVirtualVolume); }
  inline void      moveCursorZ          ()                                                               { _moveFZWFunc(_tVirtualVolume); }
  inline void      moveCursorC          ()                                                               { _moveFCWFunc(_tVirtualVolume); }
  inline void      moveCursorT          ()                                                               { _moveFTWFunc(_tVirtualVolume); }
  inline void      moveCursorU          ()                                                               { _moveFUWFunc(_tVirtualVolume); }
  inline void      reverseMoveCursorX   ()                                                               { _moveBXWFunc(_tVirtualVolume); }
  inline void      reverseMoveCursorY   ()                                                               { _moveBYWFunc(_tVirtualVolume); }
  inline void      reverseMoveCursorZ   ()                                                               { _moveBZWFunc(_tVirtualVolume); }
  inline void      reverseMoveCursorC   ()                                                               { _moveBCWFunc(_tVirtualVolume); }
  inline void      reverseMoveCursorT   ()                                                               { _moveBTWFunc(_tVirtualVolume); }
  inline void      reverseMoveCursorU   ()                                                               { _moveBUWFunc(_tVirtualVolume); }
  inline void      moveCursorByOffset   (const XVImageSize &off)                                         { _moveOffsetFunc(_tVirtualVolume, reinterpret_cast<const ML_NAMESPACE::ImageVector&>(off)); }
  inline void      resetCursor          ()                                                               { _resetCursorFunc(_tVirtualVolume); }
  inline bool      moveCursorXWrapAround()                                                               { return _moveCursorFXLFFunc(_tVirtualVolume); }
 
 
  //---------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------
  template <typename DATATYPE>
  SO_VIRTUALVOLUME_EXPORT void getValue(const XVImageSize &pos, DATATYPE &retVal);

  template <typename DATATYPE>
  SO_VIRTUALVOLUME_EXPORT void setValue(const XVImageSize &pos, DATATYPE data);

  template <typename DATATYPE>
  SO_VIRTUALVOLUME_EXPORT void setCursorValue(DATATYPE val);

  template <typename DATATYPE>
  SO_VIRTUALVOLUME_EXPORT void getCursorValue(DATATYPE &retVal);

  template <typename DATATYPE>
  SO_VIRTUALVOLUME_EXPORT void fill(const XVImageSize &boxV1, const XVImageSize &boxV2, DATATYPE value);

  template <typename DATATYPE>
  SO_VIRTUALVOLUME_EXPORT void getWrittenPageData(MLuint32 wp, DATATYPE *&dataPtr) const;
 
protected:
  SO_VIRTUALVOLUME_EXPORT SoVirtualVolume(const SoVirtualVolume &virtVol);

  SO_VIRTUALVOLUME_EXPORT SoVirtualVolume &operator=(const SoVirtualVolume &virtVol);

  SO_VIRTUALVOLUME_EXPORT void               _updateVirtualVolumes(const XVImageSize &ext           = XVImageSize(0),
                                                                   double             fillVal       = 0,
                                                                   MLDataType         dType         = MLuint8Type,
                                                                   long               maxNumKB      = -1,
                                                                   bool               useExceptions = false);
  SO_VIRTUALVOLUME_EXPORT void               _createTypedVirtualVolume();

  SO_VIRTUALVOLUME_EXPORT void               _removeVirtualVolumes(bool removeOnlyTyped=false);

  SO_VIRTUALVOLUME_EXPORT static void        _imageChangedCB(void *clientData, SoSensor *sensor);

  SoSFMLImage       *_image;

  MLDataType         _constructorDataType;

  long               _constructorMaxNumKB;

  bool               _constructorAreExceptionsOn;

  SoFieldSensor      _fieldSensor;

  ML_NAMESPACE::VirtualVolume *_virtualVolume;

  void              *_tVirtualVolume;
 
private:
  void _enforceInst();

  void _enforceInst2();
 
  //---------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------
  typedef const ML_NAMESPACE::ImageVector &(*GetCursorPosWFuncType         )(void *vv)                                                               ;
  typedef MLint             (*GetIntVoxelWFuncType          )(void *vv, const ML_NAMESPACE::ImageVector &pos)                                        ;
  typedef MLint64           (*GetInt64VoxelWFuncType        )(void *vv, const ML_NAMESPACE::ImageVector &pos)                                        ;
  typedef MLdouble          (*GetDoubleVoxelWFuncType       )(void *vv, const ML_NAMESPACE::ImageVector &pos)                                        ;
  typedef MLldouble         (*GetLDoubleVoxelWFuncType      )(void *vv, const ML_NAMESPACE::ImageVector &pos)                                        ;
  typedef MLint             (*GetIntCursorVoxelWFuncType    )(void *vv)                                                               ;
  typedef MLint64           (*GetInt64CursorVoxelWFuncType  )(void *vv)                                                               ;
  typedef MLdouble          (*GetDoubleCursorVoxelWFuncType )(void *vv)                                                               ;
  typedef MLldouble         (*GetLDoubleCursorVoxelWFuncType)(void *vv)                                                               ;
  typedef bool              (*IsMappedWFuncType             )(void *vv, const ML_NAMESPACE::ImageVector &pos)                                        ;
  typedef void              (*SetCursorPosWFuncType         )(void *vv, const ML_NAMESPACE::ImageVector &pos)                                        ;
  typedef void              (*SetIntVoxelWFuncType          )(void *vv, const ML_NAMESPACE::ImageVector &pos, MLint     v)                           ;
  typedef void              (*SetInt64VoxelWFuncType        )(void *vv, const ML_NAMESPACE::ImageVector &pos, MLint64   v)                           ;
  typedef void              (*SetDoubleVoxelWFuncType       )(void *vv, const ML_NAMESPACE::ImageVector &pos, MLdouble  v)                           ;
  typedef void              (*SetLDoubleVoxelWFuncType      )(void *vv, const ML_NAMESPACE::ImageVector &pos, MLldouble v)                           ;
  typedef void              (*SetIntCursorVoxelWFuncType    )(void *vv, MLint     v)                                                  ;
  typedef void              (*SetInt64CursorVoxelWFuncType  )(void *vv, MLint64   v)                                                  ;
  typedef void              (*SetDoubleCursorVoxelWFuncType )(void *vv, MLdouble  v)                                                  ;
  typedef void              (*SetLDoubleCursorVoxelWFuncType)(void *vv, MLldouble v)                                                  ;
  typedef void              (*FillIntWFuncType              )(void *vv, const ML_NAMESPACE::ImageVector &boxV1, const ML_NAMESPACE::ImageVector &boxV2, MLint     v);
  typedef void              (*FillInt64WFuncType            )(void *vv, const ML_NAMESPACE::ImageVector &boxV1, const ML_NAMESPACE::ImageVector &boxV2, MLint64   v);
  typedef void              (*FillDoubleWFuncType           )(void *vv, const ML_NAMESPACE::ImageVector &boxV1, const ML_NAMESPACE::ImageVector &boxV2, MLdouble  v);
  typedef void              (*FillLDoubleWFuncType          )(void *vv, const ML_NAMESPACE::ImageVector &boxV1, const ML_NAMESPACE::ImageVector &boxV2, MLldouble v);
  typedef void              (*MoveWFuncType                 )(void *vv)                                                               ;
  typedef void              (*MoveOffsetWFuncType           )(void *vv, const ML_NAMESPACE::ImageVector &off)                                        ;
  typedef void              (*ResetCursorWFuncType          )(void *vv)                                                               ;
  typedef bool              (*MoveCursorFXLFWFuncType       )(void *vv)                                                               ;
 
  //---------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------
  GetCursorPosWFuncType          _getCursorPosWFunc          ;
  GetIntVoxelWFuncType           _getIntVoxelWFunc           ;
  GetInt64VoxelWFuncType         _getInt64VoxelWFunc         ;
  GetDoubleVoxelWFuncType        _getDoubleVoxelWFunc        ;
  GetLDoubleVoxelWFuncType       _getLDoubleVoxelWFunc       ;
  GetIntCursorVoxelWFuncType     _getIntCursorVoxelWFunc     ;
  GetInt64CursorVoxelWFuncType   _getInt64CursorVoxelWFunc   ;
  GetDoubleCursorVoxelWFuncType  _getDoubleCursorVoxelWFunc  ;
  GetLDoubleCursorVoxelWFuncType _getLDoubleCursorVoxelWFunc ;
  IsMappedWFuncType              _isMappedWFunc              ;
  SetCursorPosWFuncType          _setCursorPosWFunc          ;
  SetIntVoxelWFuncType           _setIntVoxelWFunc           ;
  SetInt64VoxelWFuncType         _setInt64VoxelWFunc         ;
  SetDoubleVoxelWFuncType        _setDoubleVoxelWFunc        ;
  SetLDoubleVoxelWFuncType       _setLDoubleVoxelWFunc       ;
  SetIntCursorVoxelWFuncType     _setIntCursorVoxelWFunc     ;
  SetInt64CursorVoxelWFuncType   _setInt64CursorVoxelWFunc   ;
  SetDoubleCursorVoxelWFuncType  _setDoubleCursorVoxelWFunc  ;
  SetLDoubleCursorVoxelWFuncType _setLDoubleCursorVoxelWFunc ;
  FillIntWFuncType               _fillIntWFunc               ;
  FillInt64WFuncType             _fillInt64WFunc             ;
  FillDoubleWFuncType            _fillDoubleWFunc            ;
  FillLDoubleWFuncType           _fillLDoubleWFunc           ;
  MoveWFuncType                  _moveFXWFunc                ;
  MoveWFuncType                  _moveFYWFunc                ;
  MoveWFuncType                  _moveFZWFunc                ;
  MoveWFuncType                  _moveFCWFunc                ;
  MoveWFuncType                  _moveFTWFunc                ;
  MoveWFuncType                  _moveFUWFunc                ;
  MoveWFuncType                  _moveBXWFunc                ;
  MoveWFuncType                  _moveBYWFunc                ;
  MoveWFuncType                  _moveBZWFunc                ;
  MoveWFuncType                  _moveBCWFunc                ;
  MoveWFuncType                  _moveBTWFunc                ;
  MoveWFuncType                  _moveBUWFunc                ;
  MoveOffsetWFuncType            _moveOffsetFunc             ;
  ResetCursorWFuncType           _resetCursorFunc            ;
  MoveCursorFXLFWFuncType        _moveCursorFXLFFunc         ;
 
protected:
  void _enforceInstPub() { _enforceInst(); }

  void _enforceInstPub2() { _enforceInst2(); }
 
};
 
#endif