SoView2D.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 "SoSFMLImage.h"
#include "SoView2DSystem.h"
#include "SoView2DExtension.h"
 
#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>
 
#include <SoInteractionProvider.h>
 
class View2DSliceList;
class View2DCine;
class View2DFont;
class View2DLut;
 
class SoInteractionHandler;
 
ML_START_NAMESPACE
 
  class LUTFunction;
  template <typename T> class LUTData;
 
ML_END_NAMESPACE
 
typedef int (*SliceInitFunc) (const SoView2D *view2D, SoSFMLImage *image, void *user);
 
 
//=============================================================
 
//=============================================================
class SOVIEW2D_API SoView2D : public SoShape, public SoInteractionOwner
{
 
  SO_NODE_HEADER(SoView2D);
 
public:
 
  SoSFString instanceName;
 
  SoSFString interactionProviderID;
 
  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 userIndex;
  SoSFInt32 maxUserIndex;
  SoSFInt32 slab;
  SoSFBool unzoomOnImageChange;
 
  SoSFTrigger forceImageUpdate;
 
  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;
 
  SoSFEnum    sliceAlignX;
  SoSFEnum    sliceAlignY;
 
 
  SoSFEnum    zoomMode;
  SoSFFloat   zoomModeParameter;
 
  SoSFBool    invertKeyPanningDirections;
  SoSFBool    invertKeySlicingDirection;
  SoSFBool    wrapAroundTimePointScrolling;
 
  SoSFBool    overrideAspectRatio;
  SoSFFloat   overrideAspectRatioValue;
 
  SoSFColor   backgroundColor;
  SoSFFloat   backgroundAlphaFactor;
 
  SoSFBool    clipBackgroundToImage;
 
  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;
 
  SoSFBool    cineModeActive;
 
 
 
 
  SoSFTrigger deleteSelected;
  SoSFTrigger edit;
 
  SoSFString  status;
 
  SoSFString seriesInstanceUID;
  SoSFString frameOfReferenceUID;
 
  SoSFBool    deletingEnabled;
 
 
  SoSFTrigger renderingDone;
 
  static void    initClass();
 
  SoView2D();
 
  SbString getViewerId() const { return viewerId.getValue(); }
  View2DSliceList* getSliceList();
 
  SbVec2f getSliceSize();
 
  SoAction *getAction() { return _action; }
 
  void  GLRender(SoGLRenderAction *action) override;
 
  void updateSliceListOnImageChange();
 
  void updateLayout(int viewportX, int viewportY, int viewportWidth, int viewportHeight, bool is3D = false);
 
  void  handleEvent(SoHandleEventAction *action) override;
  bool handleKeyboardEvent(int nKey, bool shift, bool alt, bool ctrl);
 
  void  computeBBox(SoAction * action, SbBox3f &box, SbVec3f &center) override;
  void generatePrimitives(SoAction *action) override;
  void rayPick(SoRayPickAction * action) override;
 
  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();
 
  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, View2DLut* data, SoSFMLImage* img, View2DLutPrecision precision);
 
  void startCineMode();
 
  void stopCineMode();
 
  SbVec2f getSingleSliceSize (int windowX, int windowY);
 
  int getMaxStartSlice();
 
  static std::string getDICOMTagValue(SoSFMLImage* image, const std::string& dicomTagName);
 
  static SoInteractionProvider* getInteractionProvider(SoNode* node);
 
protected:
  ~SoView2D() override;
 
 
  void objRef() override { ref(); }
  void objUnref() override { unref(); }
 
  std::string getID() const override;
 
  void updateKeyboardActionEnabledStateCB(SoField*);
  void updateKeyboardActionEnabledState();
 
  void forceImageUpdateChangedCB(SoField* field = nullptr);
 
  SbBool isMouseButtonPressed(int i);
 
  bool isDeviceCoordInViewerArea (float dx, float dy, const SbVec2s& viewportSize) const;
 
  void imageChangedCB(SoField*);
  void imageChanged();
  void maxSizeChangedCB(SoField*);
 
  void sliceUnzoomCB(SoField*);
  void sliceUnzoomAction (void);
 
  void updateViewingCenterAndPlaneCB(SoField*);
  void updateViewingCenterAndPlane();
 
  void enableViewingCenterChangedCB(SoField*);
 
  void viewingCenterChangedCB(SoField*);
  void viewingCenterChanged();
 
  void updateSliceRepresentingPlane(const SbVec3f& worldCenter);
 
  void sliceZoomChangedCB(SoField*);
  void sliceZoomChanged();
 
  void sliceZoomSynchronizedChangedCB(SoField*);
  void sliceZoomSynchronizedChanged();
 
  void keepSlicesInViewCB (SoField*);
 
  int setStartSlice (int slice, bool keepInView = false, bool noCB = false);
 
  void minSliceZoomKeyboardCB(SoField*);
 
  void startCineModeCB(SoField*);
  void stopCineModeCB(SoField*);
 
  void cineParametersChangedCB(SoField*);
  void updateCineParameters();
 
  void deleteSelectedObjectCB(SoField*);
  void deleteSelectedObjectAction();
  void editObjectsCB(SoField*);
  void editObjectsAction();
 
  void        handleScheduledActions(const SoNodeList* primitives);
 
  void getLutFromScene(SoAction* action, View2DLut* data);
 
  void layoutSlices(int wx, int wy);
 
  void updateLayoutAndDraw(int originX, int originY, int width, int height, bool updateLayoutOnly,
                           SoNodeList* primitives=nullptr,int sharedCacheContext=-1, bool is3D = false, bool reverse = false);
 
  bool checkValid();
 
  SoAction *_action;
 
  View2DSliceList   *_sliceList;
  static ml::LUTFunction   *_localLut;
  View2DLut         *_lutData;
 
  MLDataType _currentLUTImageDataType;
  double _currentLUTImageMin;
  double _currentLUTImageMax;
  int _currentLUTImageNumChannels;
 
  View2DCine *_cine;
 
  SbBool            _mouseButton[3];
 
  SoFieldSensor *_viewingCenterSensor;
 
  SoFieldSensor *_startSliceSensor;
 
  SoFieldSensor *_sliceZoomSynchronizedSensor;
 
  SoFieldSensor *_sliceOriginSensor;
 
  bool _editObjectsScheduled;
  bool _deleteSelectedObjectScheduled;
 
  bool _dragging;
  bool _mouseOverViewer;
 
  SliceInitFunc _sliceInitFunc;
  void *_sliceInitUser;
 
  unsigned int _imageSerialNumber;
 
  friend class View2DInteractionHandler;
  friend class View2DInteractionProvider;
 
  SoInteractionHandler*  _interactionHandler;
  SoInteractionProvider* _interactionProvider;
 
  void updateHighColorDepthFlag();
 
  bool _useHighColorDepth;
  bool _allowHighColorDepthUpgrade;
};