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

Go to the documentation of this file.

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

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

#ifndef __SoView2DSystem_H
#include "SoView2DSystem.h"
#endif
#ifndef __SoSFMLImage_H
#include "SoSFMLImage.h"
#endif
#ifndef __SoView2DExtension_H
#include "SoView2DExtension.h"
#endif
#ifndef __View2DTexture_H
#include "View2DTexture.h"
#endif

class View2DSliceList;
class View2DShader;
class SoNodeList;

// declare the LUTData
ML_START_NAMESPACE

  template <typename T> class LUTData;

ML_END_NAMESPACE

#define VIEW2D_MAX_OVERLAY_TEXTURES 8

enum {
  // (if the type for slice indices is changed to a bigger type
  //  than int, change this constant, too!)
  NO_SLICE_ID  = 0x80000000
};

#ifndef CACHING_MODE_DEFINED
#define CACHING_MODE_DEFINED

enum SLICE_CACHING_MODE {
  SLICE_CACHING_OFF      = 0x01,
  SLICE_CACHING_PARTIAL  = 0x02,
  SLICE_CACHING_COMPLETE = 0x03
};
#endif

enum sliceBlendModeType {
  BLEND_MAXIMUM = 0,
  BLEND_ADD,
  BLEND_MINIMUM,
  BLEND_REPLACE,
  BLEND_REVERSE_SUBTRACT,
  BLEND_SUBTRACT,
  BLEND_BLEND,
  BLEND_NUMENTRIES
};

enum sliceAlignXMode {
  SLICE_ALIGNX_CENTER=0,
  SLICE_ALIGNX_LEFT,
  SLICE_ALIGNX_RIGHT
};

enum sliceAlignYMode {
  SLICE_ALIGNY_CENTER=0,
  SLICE_ALIGNY_TOP,
  SLICE_ALIGNY_BOTTOM
};

//-------------------------------------------------------------
class SOVIEW2D_API View2DSlice {
public:
  View2DSlice();
  ~View2DSlice();

  void destroy();

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

  void setShaders(View2DShader* shader, View2DShader** overlayShaders);

  View2DShader* getShader() { return _shader; }

  void     setSliceZ(int z);
  int      getSliceZ();

  void     setDrawsData(bool flag);

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

  float getAspectRatio() { return _aspectRatio; }

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

  void setSliceAlignment(sliceAlignXMode x, sliceAlignYMode y);

  void setFixedInnerZoom(bool flag, float fixedZoom);

  void     setDrawSize(float  sx, float  sy);
  void     getDrawSize(float &sx, float &sy);

  void     setDrawPosition(float x, float y);
  void     getDrawPosition(float &x, float &y);

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

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

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

  void     getVoxelSize(float &vx,float &vy, float &vz);

  void updateLayout();

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

  void setBlendMode(int blendMode, float* blendColor=NULL);

  void setBackgroundColor(float* color);

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

  void drawBackground();

  void     drawSlice(View2DSliceList *dsl, int originX, int originY, int width, int height,
                     SoNodeList* extensions, bool extensionsOnly, bool isSlabRendering);

  void drawTexture(View2DTexture* texture, int blendMode);
  void drawTexture(View2DTexture* texture, int blendMode, float* blendColor);
  void drawTexture(View2DTexture* texture, int blendMode, float* blendColor,View2DTextureFilter filter);

  void drawTexture(View2DTexture* texture, float vp1[3], float vp2[3], float vp3[3],
                   int blendMode, float* blendColor);

  void drawTexture(View2DTexture* texture, float vp1[3], float vp2[3], float vp3[3],
                   int blendMode, float* blendColor, View2DTextureFilter filter);


  bool    select(float x, float y, float &voxelX, float &voxelY, float &voxelZ);

  bool    select(float x, float y, SbVec3f &voxel);

  bool    select(const SbVec2f& d, SbVec3f &voxel);

  bool isSliceHit(float x, float y);

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

  bool isValidVoxel(const SbVec3f& voxel);

  void     invalidate();

  void     invalidateView();

  float   millimeterToPixel(float lengthMillimeter);

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

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

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

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

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

  void     mapWorldToDevice(const SbVec3f &worldCoord,
                            SbVec2f& r);

  void     getVisibleDeviceRect(float &dx1,float &dy1, float &dx2, float &dy2);

  View2DTexture* getOverlayTexture(void* user = NULL, int id = 0);

  int getLutSize();

  float getInnerZoom();

  void setDraw3D(bool flag, float devicePixelSize = 1);

  bool is3D() { return _is3D; }

  bool containsVoxel(const SbVec3f& voxelPos);

private:
  void* getImageSlice(int slice);


  int              _sliceZ;
  int              _timePoint;
  float            _drawPosX;
  float            _drawPosY;
  float            _drawSizeX;
  float            _drawSizeY;

  View2DTextureFilter _filter;
  int              _blendMode;
  float            _blendColor[4];
  float            _bgColor[4];
  float            _zoom;
  float            _sliceZoom;
  float            _sliceOriginX;
  float            _sliceOriginY;

  float            _fixedInnerZoom;
  bool             _fixedInnerZoomOn;


  SoSFMLImage         *_inp;

  float            _centerX;
  float            _centerY;

  int _imageX;
  int _imageY;

  float _vx,_vy,_vz;

  float _aspectRatio;

  bool             _drawData;
  bool             _is3D;

  sliceAlignXMode _sliceAlignX;
  sliceAlignYMode _sliceAlignY;

  SLICE_CACHING_MODE    _caching;

  View2DTexture _sliceTexture;
  View2DTexture *_overlayTextures[VIEW2D_MAX_OVERLAY_TEXTURES];

  View2DShader* _shader;
  View2DShader** _overlayShaders;
};

#endif