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;

  SoSFString userInfo;

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