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

Go to the documentation of this file.

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

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

// define the below to compile in debug output of field changes on SoView2D nodes
//#define SOVIEW2D_TRACE

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

#include <Inventor/fields/SoFields.h>
#include <Inventor/nodes/SoSubNode.h>
#include <Inventor/nodes/SoShape.h>
#include <Inventor/sensors/SoTimerSensor.h>
#include <Inventor/sensors/SoAlarmSensor.h>
#include <Inventor/sensors/SoFieldSensor.h>
#include <Inventor/sensors/SoNodeSensor.h>
#include <Inventor/nodes/SoSubNode.h>
#include <Inventor/elements/SoCacheElement.h>

class View2DSliceList;
class View2DFont;

class SoInteractionHandler;
class SoInteractionProvider;

ML_START_NAMESPACE

  class LUTFunction;
  template <typename T> class LUTData;

ML_END_NAMESPACE

typedef enum View2DCineMode {
  CINE_Z=0, CINE_T, CINE_ZT,
} View2DCineModeType;

typedef enum View2DCineDir {
  CINE_FORWARD=0, CINE_PINGPONG
} View2DCineDirType;

typedef enum View2DCineRepeat {
  CINE_ONCE=0, CINE_REPEAT
} View2DCineRepeatType;

typedef enum View2DZoomMode {
  VIEW2D_AUTO_ZOOM,
  VIEW2D_AUTO_ZOOM_X,
  VIEW2D_AUTO_ZOOM_Y,
  VIEW2D_FIXED_PIXELS_PER_VOXEL_X,
  VIEW2D_FIXED_PIXELS_PER_VOXEL_Y,
  VIEW2D_FIXED_PIXELS_PER_MM,
  VIEW2D_FIXED_MM_PER_VIEWER_HEIGHT,
  VIEW2D_FIXED_MM_PER_VIEWER_WIDTH,
  VIEW2D_SCALE_TO_VIEWER_IGNORE_RATIO
} View2DZoomModeType;

enum View2DLutPrecision {
  VIEW2D_LUT_AUTO,
  VIEW2D_LUT_8BIT,
  VIEW2D_LUT_12BIT,
  VIEW2D_LUT_16BIT
};

typedef int (*SliceInitFunc) (const SoView2D *view2D, SoSFMLImage *image, void *user);


//=============================================================

//=============================================================
class SOVIEW2D_API SoView2D : public SoShape {

  SO_NODE_HEADER(SoView2D);

public:

  SoSFMLImage image;

  SoSFBool  drawImageData;

  SoSFString viewerId;

  SoSFEnum  blendMode;
  SoSFEnum  filterMode;
  SoSFEnum  cacheMode;
  SoSFFloat alphaFactor;
  SoSFColor baseColor;
  SoSFBool useShaders;
  SoSFBool applyLut;
  SoSFEnum lutPrecision;

  SoSFInt32 startSlice;
  SoSFInt32 sliceStep;
  SoSFInt32 numSlices;
  SoSFInt32 numXSlices;
  SoSFInt32 maxSlice;
  SoSFBool keepSlicesInView;
  SoSFInt32 timePoint;
  SoSFInt32 maxTimePoint;
  SoSFInt32 slab;
  SoSFBool unzoomOnImageChange;


  SoSFVec2f margin;
  SoSFVec2f spacing;

  SoSFPlane plane;

  SoSFVec2f lowerLeft;
  SoSFVec2f upperRight;

  SoSFBool  snapToCenter;

  SoSFBool  standardKeys;
  SoSFBool  standardKeysNumbers;
  SoSFBool  standardKeysNeedValidPosition;

  SoSFBool  passHandledFlagToInventor;

  SoSFBool  reverseExtensionDrawingOrder;

  SoSFVec2f sliceOrigin;
  SoSFFloat sliceZoom;
  SoSFFloat sliceZoomSynchronized;
  SoSFVec2f zoomCenter;
  
  SoSFVec3f viewingCenter;

  SoSFBool  enableViewingCenter;

  SoSFFloat minSliceZoomKeyboard;

  SoSFTrigger unzoom;

  SoSFColor   backgroundColor;
  SoSFFloat   backgroundAlphaFactor;

  SoSFBool    handle2DEvents;

  SoSFBool    handle3DEvents;

  SoSFBool    useManagedInteraction;

  SoSFBool    enableZBuffer;

  SoSFBool    enableZWrite;

  SoSFFloat   devicePixelSize;



  SoSFTrigger startCine;
  SoSFTrigger stopCine;
  SoSFInt32   cineCenterT;
  SoSFInt32   cineIntervalT;
  SoSFInt32   cineCenterZ;
  SoSFInt32   cineIntervalZ;
  SoSFEnum    cineMode;
  SoSFEnum    cineDirection;
  SoSFEnum    cineRepeat;
  SoSFFloat   cineSpeed;

  SoSFBool    cineFullRangeZ;
  SoSFBool    cineFullRangeT;

  SoSFBool    cineAlwaysReset;

  SoSFEnum    sliceAlignX;
  SoSFEnum    sliceAlignY;


  SoSFEnum    zoomMode;
  SoSFFloat   zoomModeParameter;

  SoSFBool    invertKeyPanningDirections;

  SoSFBool    overrideAspectRatio;
  SoSFFloat   overrideAspectRatioValue;


  SoSFTrigger deleteSelected;
  SoSFTrigger edit;

  SoSFString  status;

  SoSFString  seriesInstanceUID;

  SoSFBool    deletingEnabled;



  static void    initClass();

  SoView2D();

  SbString getViewerId() const { return viewerId.getValue(); }
  View2DSliceList* getSliceList();

  SbVec2f getSliceSize();

  SoAction *getAction() { return _action; }

  virtual void  GLRender(SoGLRenderAction *action);
  virtual void  handleEvent(SoHandleEventAction *action);
  virtual void  computeBBox(SoAction * action, SbBox3f &box, SbVec3f &center);
  virtual void generatePrimitives(SoAction *action);

  bool getEventLocation(SoHandleEventAction* action,
                        bool& hit, float& dx, float& dy, SbVec3f& voxelHit,
                        int& sliceID);


  static View2DFont* globalFont();

  static View2DFont* globalFont(int /*cacheContext*/) { return globalFont(); }

  static View2DFont& globalFontRef();

  int currentContext() { return _currentContext; }

  void setSliceInitFunc (SliceInitFunc fn, void *user)
  { _sliceInitFunc = fn; _sliceInitUser = user; }

  SliceInitFunc getSliceInitFunc (void) { return _sliceInitFunc; }

  int getCurrentCenterSlice();

  void adjustSliceOriginToCenter(float newSliceZoom);

  void translateInnerSlice(float x, float y);

  void getStatusString(SbString& string);

  ml::LUTFunction* getDefaultLut() { return _localLut; }

  ml::LUTFunction* getLutFromScene(SoAction* action);

  bool updateLutData(ml::LUTFunction* lut, ml::LUTData<MLuint8>* data, SoSFMLImage* img, View2DLutPrecision precision);

  void        startCineMode();

  void        stopCineMode();

  SbVec2f getSingleSliceSize (int windowX, int windowY);

  int getMaxStartSlice();

protected:
  virtual ~SoView2D();

  SbBool isMouseButtonPressed(int i);

  bool isDeviceCoordInViewerArea (float dx, float dy, SoHandleEventAction *action);

  static void imageChangedCB(void *data, SoSensor* a);
  void imageChanged();

  static void sliceUnzoomCB(void *data, SoSensor* a);
  void sliceUnzoomAction (void);

  static void updateViewingCenterCB(void *data, SoSensor* a);
  void updateViewingCenter();

  static void enableViewingCenterChangedCB(void *data, SoSensor* a);

  static void viewingCenterChangedCB(void *data, SoSensor* a);
  void viewingCenterChanged();

  static void sliceZoomChangedCB(void *data, SoSensor* a);
  void  sliceZoomChanged();

  static void sliceZoomSynchronizedChangedCB(void *data, SoSensor* a);
  void  sliceZoomSynchronizedChanged();

  static void keepSlicesInViewCB (void *data, SoSensor* a);

  int setStartSlice (int slice, bool keepInView = false, bool noCB = false);

  static void minSliceZoomKeyboardCB(void *data, SoSensor* a);

  static void cineTimerSensorCB(void *data, SoSensor* a);
  void        cineTimerSensor();

  static void startCineModeCB(void *data, SoSensor* a);
  static void stopCineModeCB(void *data, SoSensor* a);

  static void deleteSelectedObjectCB(void *data, SoSensor* a);
  void        deleteSelectedObjectAction();
  static void editObjectsCB(void *data, SoSensor* a);
  void        editObjectsAction();

  void        handleScheduledActions(const SoNodeList* primitives);

  int getCineStartZ();
  int getCineEndZ();
  int getCineStartT();
  int getCineEndT();

  void getLutFromScene(SoAction* action, ml::LUTData<MLuint8>* data);

  void layoutSlices(int wx, int wy);

  void updateLayoutAndDraw(int originX, int originY, int width, int height, bool updateLayoutOnly,
                           SoNodeList* primitives=0,int sharedCacheContext=-1, bool is3D = false, bool reverse = false);

  bool handleKeyboardEvent(int nKey, bool shift, bool alt, bool ctrl);

  SoAction *_action;

  View2DSliceList   *_sliceList;
  ml::LUTFunction   *_localLut;
  ml::LUTData<MLuint8>  *_lutData;

  MLDataType _currentLUTImageDataType;
  double _currentLUTImageMin;
  double _currentLUTImageMax;
  int _currentLUTImageNumChannels;


  SbBool            _mouseButton[3];

  SoTimerSensor     *_cineTimer;
  SoFieldSensor     *_imageSensor;
  SoFieldSensor     *_startCine;
  SoFieldSensor     *_stopCine;
  SoFieldSensor *_sliceUnzoom;
  SoFieldSensor *_minSliceZoomKeyboardSensor;
  SoFieldSensor *_editObjects;
  SoFieldSensor *_deleteSelectedObject;

  SoFieldSensor *_viewingCenterSensor;
  SoFieldSensor *_enableViewingCenterSensor;

  SoFieldSensor *_sliceAlignXSensor;
  SoFieldSensor *_sliceAlignYSensor;

  SoFieldSensor *_startSliceSensor;
  SoFieldSensor *_numSlicesSensor;
  SoFieldSensor *_sliceStepSensor;
  SoFieldSensor *_keepSlicesInViewSensor;

  SoFieldSensor *_sliceZoomSensor;

  SoFieldSensor *_sliceZoomSynchronizedSensor;

  SoFieldSensor *_sliceOriginSensor;

  bool               _cineStep;
  bool               _cineBackward;

  bool _editObjectsScheduled;
  bool _deleteSelectedObjectScheduled;

  bool _dragging;

  View2DEvent _lastPressEvent;

  SliceInitFunc _sliceInitFunc;
  void *_sliceInitUser;

  unsigned int _imageSerialNumber;

  static View2DFont* _globalFont;
  int _currentContext;

  friend class View2DInteractionHandler;
  friend class View2DInteractionProvider;

  SoInteractionHandler*  _interactionHandler;
  SoInteractionProvider* _interactionProvider;

#ifdef SOVIEW2D_TRACE

  SoNodeSensor      *_debugSensor;

  static void debugSensorCB(void *data, SoSensor *sensor);
  void debugSensor(SoNodeSensor* sensor);
#endif
};

#endif