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     setUserIndex(int userIndex);
  int      getUserIndex();

  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 getStartSlice() const;

  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              _userIndex;
  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;
};