View2DSliceList.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 "View2DSlice.h"
 
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(View2DAlignXMode x, View2DAlignYMode y);
 
  void setAspectRatio(float ratio) { _aspectRatio = ratio; }
 
  float getAspectRatio() { return _aspectRatio; }
 
  void setFixedInnerZoom(bool flag, float fixedZoom);
 
  void     setBlendMode(int blendMode = 0,  float *_blendColor=nullptr);
  int      getBlendMode();
 
  float*   getBlendColor();
 
  void setDrawsData(bool flag);
 
  void setUseShaders(bool flag) { _useShaders = flag; }
 
  void initGL();
 
  View2DShader* createShader();
 
  void       setLut(View2DLut* lut);
  View2DLut* 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(View2DSliceCachingMode mode);
  View2DSliceCachingMode getCachingMode();
 
  void setBackgroundColor(float* color);
 
  void setClipBackgroundToImage( bool value );
 
   bool    drawSlices(int originX, int originY, int width, int height, bool updateLayoutOnly,
                      SoNodeList* extensions = nullptr, 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 mapWorldToVoxel(double  worldX, double  worldY, double  worldZ,
                       double &voxelX, double &voxelY, double &voxelZ);
 
  void mapVoxelToWorld(float   voxelX, float   voxelY, float   voxelZ,
                       float &worldX, float &worldY, float &worldZ);
 
  void mapVoxelToWorld(double  voxelX, double  voxelY, double  voxelZ,
                       double &worldX, double &worldY, double &worldZ);
 
  bool isSliceHit(int x, int y);
 
  int getSliceAtDevicePosition(int x, int y) const;
 
  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 = nullptr);
 
  // 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& worldCoord, SbVec2f& r);
 
  void mapWorldToVoxel(const SbVec3f& worldCoord,SbVec3f& voxelCoord);
  void mapWorldToVoxel(const SbVec3d& worldCoord,SbVec3d& voxelCoord);
 
  void mapVoxelToWorld(const SbVec3f& voxelCoord,SbVec3f& worldCoord);
  void mapVoxelToWorld(const SbVec3d& voxelCoord,SbVec3d& 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);
 
  bool mapDeviceToNormalizedCoordinateSystem(int x, int y, SbVec2f &normalizedCoordinate) const;
 
  SbVec3f getWorldAxis(int a);
 
  SbVec3d getWorldAxisDouble(int a);
 
  void getImageSize(int &x, int &y, int &z);
 
  void             updateSliceList(int sharedContextId=-1, bool layoutOnly=false);
 
  View2DSlice*     getSlice(int z) const;
 
  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 = nullptr);
 
  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 = nullptr);
 
  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;
 
  View2DLut*       _lut;
 
  int              _blendMode;
  float            _blendColor[4];
  float            _bgColor[4];
  bool             _clipBackgroundToImage;
  View2DTextureFilter _filter;
  bool             _drawData;
  bool             _is3D;
  float            _devicePixelMM;
  SbVec3f          _sliceNormal;
 
  View2DAlignXMode _sliceAlignX;
  View2DAlignYMode _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;
 
  View2DSliceCachingMode    _caching;
};