View2DSlice.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
**
**************************************************************************************/
 
 
 
#pragma once
 
#include "SoView2DSystem.h"
#include "SoSFMLImage.h"
#include "SoView2DExtension.h"
#include "View2DTexture.h"
 
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 32
 
enum {
  // (if the type for slice indices is changed to a bigger type
  //  than int, change this constant, too!)
  NO_SLICE_ID  = 0x80000000
};
 
//-------------------------------------------------------------
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(View2DAlignXMode x, View2DAlignYMode 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(View2DSliceCachingMode mode);
  View2DSliceCachingMode getCachingMode();
 
  void     getVoxelSize(float &vx,float &vy, float &vz);
 
  void     getVoxelSize(double &vx, double &vy, double &vz);
 
  void updateLayout();
 
  void setLut(View2DLut* lut);
 
  void setBlendMode(int blendMode, float* blendColor=nullptr);
 
  void setBackgroundColor(float* color);
 
  void   setTimePoint(int timepoint);
  int    getTimePoint();
 
  void   setUserIndex(int useIndex);
  int    getUserIndex();
 
 
  void drawBackground(bool clipBackgroundToImage = false);
 
  void     drawSlice(View2DSliceList *dsl, int originX, int originY, int width, int height,
                     SoNodeList* extensions, bool extensionsOnly, bool isSlabRendering);
 
  void drawSliceIn3D(View2DSliceList * dsl, bool extensionsOnly, SoNodeList* extensions, bool reverseDrawingOrder);
 
  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);
 
  void getImageDeviceRect(float &dx1, float &dy1, float &dx2, float &dy2);
 
  static void enableBlending(int blendMode);
 
  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) const;
 
  void mapDeviceToNormalizedCoordinateSystem(int x, int y, SbVec2f &normalizedCoordinate) const;
 
  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);
 
  SbMatrix getWorldToDeviceMatrix();
 
  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 = nullptr, 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;
  int              _userIndex;
  float            _drawPosX;
  float            _drawPosY;
  float            _drawWidth;
  float            _drawHeight;
 
  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 _imageWidth;
  int _imageHeight;
 
  float  _vxFlt,_vyFlt,_vzFlt;
  double _vxDbl,_vyDbl,_vzDbl;
 
  float _aspectRatio;
 
  bool             _drawData;
  bool             _is3D;
 
  View2DAlignXMode _sliceAlignX;
  View2DAlignYMode _sliceAlignY;
 
  View2DSliceCachingMode    _caching;
 
  View2DTexture _sliceTexture;
  View2DTexture *_overlayTextures[VIEW2D_MAX_OVERLAY_TEXTURES];
 
  View2DShader* _shader;
  View2DShader** _overlayShaders;
};