MeVisLab/Standard/Sources/Inventor/SoView2D/View2DSliceList.h

Go to the documentation of this file.

#ifndef __View2DSliceList_H
#define __View2DSliceList_H
//----------------------------------------------------------------------------------
// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef __SoView2DSystem_H
#include "SoView2DSystem.h"
#endif
#ifndef __SoSFMLImage_H
#include "SoSFMLImage.h"
#endif
#ifndef __View2DSlice_H
#include "View2DSlice.h"
#endif

class SoNodeList;
class SoView2D;
class View2DShader;

//--------------------------------------------------------------------
class SOVIEW2D_API View2DSliceList {

public:
  View2DSliceList();
   ~View2DSliceList();

  void         setInputImage(SoSFMLImage *img);
  SoSFMLImage *getInputImage();

  void     setSliceRange(int  start, int num, int step =1);
  void     getSliceRange(int &start, int &num, int &step);

  void     setFilter(View2DTextureFilter filter = FILTER_LINEAR);
  View2DTextureFilter      getFilter();

  void setSliceAlignment(sliceAlignXMode x, sliceAlignYMode y);

  void setAspectRatio(float ratio) { _aspectRatio = ratio; }

  float getAspectRatio() { return _aspectRatio; }

  void setFixedInnerZoom(bool flag, float fixedZoom);

  void     setBlendMode(int blendMode = 0,  float *_blendColor=NULL);
  int      getBlendMode();

  float*   getBlendColor();

  void setDrawsData(bool flag);

  void setUseShaders(bool flag) { _useShaders = flag; }

  void initGL();

  void           setLut(ml::LUTData<MLuint8>* lut);
  ml::LUTData<MLuint8>*  getLut();

  void     setSliceSize(float  sizeX, float  sizeY);
  void     getSliceSize(float &sizeX, float &sizeY);

  void     setSliceSpacing(float  dx, float  dy);
  void     getSliceSpacing(float &dx, float &dy);

  void     setSliceOrigin(float  x, float  y);
  void     getSliceOrigin(float &x, float &y);

  void     setDrawOffset(float  x, float  y);
  void     getDrawOffset(float &x, float &y);

  void     setTimePoint(int timepoint);
  int      getTimePoint();

  void     setSliceZoom(float  zoom);
  float    getSliceZoom();

  void     setOwner(SoView2D* view) { _owner = view; };
  SoView2D* getOwner() { return _owner; };

  void setNumXSlices(int num);
  int  getNumXSlices();

  void setSlab(int slab);
  int  getSlab();

   void          setCachingMode(SLICE_CACHING_MODE mode);
  SLICE_CACHING_MODE getCachingMode();

  void setBackgroundColor(float* color);

   bool    drawSlices(int originX, int originY, int width, int height, bool updateLayoutOnly,
                      SoNodeList* extensions = NULL, int sharedCacheContext=-1, bool is3D = false, bool reverse = false);

  bool mapVoxelToDevice(float voxelX, float voxelY, float voxelZ,
                        float &rx, float &ry);

  bool mapWorldToDevice(float worldX, float worldY, float worldZ,
                        float &rx, float &ry);

  void mapWorldToVoxel(float   worldX, float   worldY, float   worldZ,
                       float &voxelX, float &voxelY, float &voxelZ);

  void mapVoxelToWorld(float   voxelX, float   voxelY, float   voxelZ,
                       float &worldX, float &worldY, float &worldZ);

  bool isSliceHit(int x, int y);

  int getSliceAtDevicePosition(int x, int y);

  bool  isVoxelInsideImage(float voxelX,float voxelY,float voxelZ);

  bool  is3D() { return _is3D; }

  void set3DPixelSize(float devicePixelMM) { _devicePixelMM = devicePixelMM; }

  SbVec3f  getSliceTranslation(int z);

  SbVec3f  getSliceNormal();

  bool castRayOnSlides(const SbVec3f& p1, const SbVec3f& p2, const SbVec3f& viewpoint,
    SbVec3f& worldHit, SbVec3f& voxelHit, int* sliceID = NULL);

  // SoVec3f convenience methods:

  bool mapVoxelToDevice(const SbVec3f& voxelCoord,
                        float &rx, float &ry);

  bool mapVoxelToDevice(const SbVec3f& voxelCoord, SbVec2f& r);

  bool mapWorldToDevice(const SbVec3f& worldCoord,
                        float &rx, float &ry);

  bool mapWorldToDevice(const SbVec3f& voxelCoord, SbVec2f& r);

  void mapWorldToVoxel(const SbVec3f& worldCoord,SbVec3f& voxelCoord);

  void mapVoxelToWorld(const SbVec3f& voxelCoord,SbVec3f& worldCoord);

  bool mapEventToWorld(View2DEvent* ec,
      float &worldX,
      float &worldY,
      float &worldZ);

  bool mapEventToWorld(View2DEvent* ec, SbVec3f &world);

  bool mapEventToVoxel(View2DEvent* ec,
      float &vx,
      float &vy,
      float &vz);

  bool mapEventToVoxel(View2DEvent* ec, SbVec3f &voxel);

  SbVec3f getWorldAxis(int a);

  void getImageSize(int &x, int &y, int &z);

  void             updateSliceList(int sharedContextId=-1, bool layoutOnly=false);

  View2DSlice*     getSlice(int z);

  void    getCurrentInnerZoom(float &x, float &y);

  int     getCurrentCacheContext() { return _currentCacheContext; }

  void getWindowSize(int& x, int& y) { x = _lastWindowX; y = _lastWindowY; }

  void             cleanup();

  bool shouldRenderReverse(const SbVec3f& viewdir);

  bool mapDeviceToWorld(int x, int y,
      SbVec3f& worldCoord);

  bool mapDeviceToVoxel(int x, int y,
      SbVec3f& voxelCoord,
      int* sliceID = NULL);

  bool mapDeviceToWorld(int x, int y,
      float &worldX,
      float &worldY,
      float &worldZ);

  bool mapDeviceToVoxel(int x, int y,
      float &voxelX,
      float &voxelY,
      float &voxelZ,
      int* sliceID = NULL);

  void grabSlice();
  void ungrabSlice();

private:
  void drawSlice(int slice, int count, int originX, int originY, int width, int height,
                 int sharedContextId, bool updateLayoutOnly, bool is3D, SoNodeList* extensions);

  SoSFMLImage         *_inp;

  View2DSlice      **_sliceList;
  int              _slices;

  int              _sliceStart;
  int              _sliceNum;
  int              _sliceStep;
  int              _timePoint;
  int              _numXSlices;
  int              _slab;

  float            _sliceSizeX;
  float            _sliceSizeY;
  float            _spaceX;
  float            _spaceY;
  float            _offsetX;
  float            _offsetY;

  int              _lastWindowX;
  int              _lastWindowY;

  float            _sliceZoom;
  float            _sliceOriginX;
  float            _sliceOriginY;

  ml::LUTData<MLuint8>*    _lut;

  int              _blendMode;
  float            _blendColor[4];
  float            _bgColor[4];
  View2DTextureFilter _filter;
  bool             _drawData;
  bool             _is3D;
  float            _devicePixelMM;
  SbVec3f          _sliceNormal;

  sliceAlignXMode _sliceAlignX;
  sliceAlignYMode _sliceAlignY;

  float            _fixedInnerZoom;
  bool             _fixedInnerZoomOn;
  float            _aspectRatio;

  int              _grabSliceCounter; // flag realized as a counter, because it can be set/unset by various agents
  int              _grabbedLayoutIndex;
  static View2DSliceList* _grabbingSliceList; // only one slice list can grab the pointer

  SoView2D* _owner;

  View2DShader* _shader;
  View2DShader* _overlayShaders[VIEW2D_MAX_OVERLAY_TEXTURES];

  bool _useShaders;

  int _currentCacheContext;

  SLICE_CACHING_MODE    _caching;
};

#endif