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

Go to the documentation of this file.

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

//
// Originally implemented by Florian Link, now handled by Lars Bornemann
//
// Implements an editor for an XMarkerList (from MLBase) to edit
// markers (and vectors) on a SoView2D or SoOrthoView2D viewer
//----------------------------------------------------------------------------------

#ifndef __SoView2DSystem_H
#include "SoView2DSystem.h"
#endif
#ifndef __SoView2DInteractionExtension_H
#include "SoView2DInteractionExtension.h"
#endif
#ifndef __SoView2D_H
#include "SoView2D.h"
#endif
#ifndef __SoSFMLBase_H
#include "SoSFMLBase.h"
#endif

#ifndef __mlXMarkerList_H
#include "mlXMarkerList.h"
#endif
#ifndef __mlStylePalette_H
#include "mlStylePalette.h"
#endif

#ifndef __mlSphere_H
#include "mlSphere.h"
#endif
#ifndef __mlDisc_H
#include "mlDisc.h"
#endif

class View2DIcons;

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

//=============================================================
class SOVIEW2D_API SoView2DMarkerEditor : public SoView2DInteractionExtension {

  SO_NODE_HEADER(SoView2DMarkerEditor);

public:

  enum vectorDragMode {
    VECTOR_DRAG_NONE,
    VECTOR_DRAG_STARTPOINT,
    VECTOR_DRAG_ENDPOINT,
    VECTOR_DRAG_OFFSET,
    VECTOR_DRAG_MOVE,
    VECTOR_DRAG_RESIZE
  };

  enum editorModeType {
  EDIT_VECTOR=0,
  EDIT_MARKER=1,
  EDIT_OBJECT=2
  };

  enum drawModeType {
  DRAW_VECTOR=0,
  DRAW_MARKER,
//  DRAW_BOX,
  DRAW_DISC,
  DRAW_SPHERE,
  DRAW_VECTOR_AND_DISC
  };

  enum editorColorType {
  COLOR_BY_INDEX=0,
  COLOR_BY_TYPE=1,
  COLOR_BY_ID=2
  };

  enum textColorType {
  COLOR_LIKE_MARKER=0,
  COLOR_TEXT=1
  };

  enum textModeType {
  TEXT_OFF,
  TEXT_STYLEINDEX,
  TEXT_STYLENAME,
  TEXT_ITEMNAME,
  TEXT_ITEMID,
  TEXT_VOXELPOS,
  TEXT_WORLDPOS,
  TEXT_LENGTH,
  TEXT_MARKERTYPE,
  TEXT_MARKERLISTINDEX,
  };

  enum textPositionType {
  TEXT_POSITION_CENTER,
  TEXT_POSITION_ABOVE,
  TEXT_POSITION_RIGHT_ABOVE,
  TEXT_POSITION_RIGHT,
  TEXT_POSITION_RIGHT_BELOW,
  TEXT_POSITION_BELOW,
  TEXT_POSITION_LEFT_BELOW,
  TEXT_POSITION_LEFT,
  TEXT_POSITION_LEFT_ABOVE,
  };

  enum vectorArrowType {
      VECTOR_NO_ARROWS=0,
      VECTOR_END_ARROW=1,
      VECTOR_START_ARROW=2,
      VECTOR_BOTH_ARROWS=3,
      VECTOR_PLUS_MINUS=4,
      // draws vector and - vector biginning at the center,
      // e.g indication, center of mass and max expansion
      VECTOR_PM_WITH_ARR=5,
      // as above but with arrows
      BOX_START_TO_END=6,
      // draws an box with corners at the marker
      // and the marker plus vector location
      BOX_PLUS_MINUS=7,
      // draws an box with center at the marker
      // and corners at the marker plus vector
      // and marker - vector location
      // the drawing stype can be controled
      // by depthVisibility, where the bits 1..32
      // are used as flags turning on and off
      // different partes of the dephth clued
      // in the 2D projection of the box

      // draws a vector + a sphere which is defined by the vector
      // VECTOR_AND_SPHERE=8,
      // draws a vector + a dics which is defined by the vector
      // (interpreting it as its normal vector and the length of the vector as its radius)
      // VECTOR_AND_DISC=9
  };

  enum depthVectorDrawType
  {
    DRAW_NONE,      
    DRAW_HIGHLIGHT_SLICE_SEGMENT,
  };

  enum depthVisibilityType
  {
    DEPTH_IN_SLICES,
    DEPTH_IN_MM
  };


  SoSFFloat depthVisibility;

  SoSFEnum  depthVisibilityMode;

  SoSFBool  snapToVoxel;

  SoSFEnum  editorMode;

  SoSFBool  deleteOnClick;

  SoSFBool  addOnClick;

  SoSFBool  selectingOn;

  SoSFBool  actOnReleaseOnly;

  SoSFEnum  colorMode;

  SoSFEnum  textMode;
  SoSFEnum  textPosition;
  SoSFEnum  textColorMode;
  SoSFColor textColor;
  SoSFBool  textShadow;
  SoSFInt32 textFontSize;
  SoSFBool  showTextOnlyForSelectedMarker;
  SoSFBool  cutText;
  SoSFInt32 maxNumberOfLines;

  SoSFEnum vectorArrow;
  SoSFInt32 vectorLineWidth;

  SoSFFloat alphaFactor;

  SoSFFloat minimumAlpha;

  SoSFInt32 currentType;

  SoSFMLBase  outputMLModule;

  SoSFMLBase  stylePalette;

  SoSFBool drawMarkerShapesWithLines;

  SoSFBool    useIconFile;
  SoSFInt32   iconIdx;
  SoSFString  iconFile;
  SoSFString  internalIconFile;

  SoSFInt32   currentStyleIndex;

  SoSFEnum    depthVectorDrawMode;

  SoSFEnum    drawMode;

  SoSFBool    highlightSelection;

  SoSFBool useAntiAlias;

  SoSFBool useVectorLengthAsMarkerSize;

  SoSFBool    selectiveDrawing;

  SoSFBool selectionBoxesForCurrentOnly;

  SoSFBool  cooperative;

  SoSFBool busy;

  SoSFBool  snapToSlice;
    
  SoSFBool overwriteCurrentTimePoint;
  SoSFInt32 newCurrentTimePoint;


  static void   initClass();

  SoView2DMarkerEditor();

  void draw(View2DSliceList *dsl, View2DSlice* dslice, int slice);


  bool   evalEvent(SoView2D* view2d, View2DSliceList* slicelist,
                   View2DEvent* ec, View2DEventPhase phase);

  static bool handleNotificationCB(void *usrData, ml::Field* field);

  void deleteSelectedObject();

  bool isActive();

  void setupIcons();

  bool ignoreEvent(View2DEvent* ec);

protected:
  // stores the last cursor position where the modification (movement, resizing) of the selected marker occured
  ml::vec3 _lastWorldPosition;
  // holds the index of the currently selected marker. Can be -1, so must be signed.
  MLssize_t _selectedObjectIndex;

  bool _pointDragged;
  vectorDragMode _vectorDragged;

  ml::ListBase::ActionClass _currAction;
  MLssize_t                 _currIndex;
  ml::XMarker               _currItem;

  View2DIcons*              _icons;

  ml::XMarkerListContainer  _container;
  ml::StylePalette*         _palette;

  MLssize_t performHitTest(float deviceX, float deviceY, const SbVec3f& eventVoxel, View2DSliceList* slicelist,
                           vectorDragMode& dragMode);

  void immediateItemAction(ml::ListBase::ActionClass action, MLssize_t index);

  void itemAction(ml::ListBase::ActionClass action, MLssize_t index);

  bool startDrag(float deviceX, float deviceY, const SbVec3f& eventVoxel, View2DSliceList* slicelist,
                 bool validLocation, bool performAction);

  void performDrag(const SbVec3f& eventVoxel, View2DSliceList* slicelist);

  void finishDrag();


  virtual int getCurrentCursor(SoViewerProxy* viewerProxy);
  virtual bool isSensitiveAt(const SoPointerPosition& pos);
  virtual void startPressAt(const SoPointerPosition& pos);
  virtual void dragMoveTo(const SoPointerPosition& pos);
  virtual SoPointingAction* endPress(int clickCount);

  int  calculateCurrentStyleIndex();
  MLssize_t  isDiscHit(const ml::vec3 &cursorPosition, View2DSliceList* slicelist, vectorDragMode& dragMode);
  MLssize_t  isSphereHit(const ml::vec3 &cursorPosition, View2DSliceList* slicelist, vectorDragMode& dragMode);
  MLssize_t  isBoxHit(const ml::vec3 &cursorPosition, View2DSliceList* slicelist, vectorDragMode& dragMode);
  void resizeObject(const ml::vec3 &startCursorPosition, const ml::vec3 &endCursorPosition, ml::XMarkerList* markers);
  void moveObject(const ml::vec3 &startCursorPosition, const ml::vec3 &endCursorPosition, ml::XMarkerList* markers);
  bool markerIsHit(float markerSize, float pointX, float pointY, float centerX, float centerY,
                   bool shouldSnapToVoxel, SbVec3f hitPositionVoxel, SbVec3f markerPositionVoxel);
  bool isDepthVisible(float depthValue, float voxelSizeZ);

  float getDepthVisibilityBlendValue(float distance, float voxelSizeZ);
  bool isVectorDepthVisible(float depthValue1, float depthValue2, int slice, float voxelSizeZ);
  bool isVectorCrossedBySlice(float depthValue1, float depthValue2, int slice, float voxelSizeZ);
  bool isDiscVisible(ml::Disc* disc, View2DSliceList* slicelist, int slice);
  bool isSphereVisible(View2DSliceList* slicelist, const ml::vec3 &center, float radius, int slice);
  void drawVector(const ml::XMarker& marker, bool isSelected, int markerIndex, 
                  View2DSliceList* slicelist, View2DSlice* dslice, int slice, float voxelSizeZ, const SbVec4f& originalMarkerColor);
  void drawVectorCrossedBySlices(const ml::XMarker& marker, bool isSelected, float lineWidth, int markerIndex, View2DSliceList* slicelist, View2DSlice* dslice, int slice);
  void drawVectorCross(float deviceX1, float deviceY1, float deviceX2, float deviceY2, float lineWidth);
  void drawVectorBelow(float deviceX1, float deviceY1, float deviceX2, float deviceY2, float lineWidth);
  void drawVectorAbove(float deviceX1, float deviceY1, float deviceX2, float deviceY2, float lineWidth);
  void drawVectorBox(const ml::XMarker& marker, bool isSelected, int markerIndex, int lineWidth, View2DSliceList* slicelist, View2DSlice* dslice, int slice);
  void drawVectorArrowHeads(const ml::XMarker& marker, bool isSelected, int markerIndex, View2DSliceList* slicelist, View2DSlice* dslice, int slice);
  void drawVectorArrowHead(const SbVec2f& deviceStart, const SbVec2f& deviceEnd, bool isEndArrow);
  void drawMarker(float deviceX, float deviceY, int size, bool selected, int markerindex, const ml::XMarker& marker);
  void drawMarkerWithLines (ml::StylePalette::MarkerType markertype, float deviceX, float deviceY, float size, int lineWidth, bool antiAlias, const ml::XMarker& marker);
  int getPaletteIndex(const ml::XMarker& marker, int i);
  void drawSphere(ml::Sphere* s, View2DSliceList *dsl, View2DSlice* dslice, int slice, float r, float g, float b, bool bHighlight, float alphaFactor=1.0f) ;
  void drawDisc(ml::Disc* d, View2DSliceList *dsl, View2DSlice* dslice, int slice, float r, float g, float b, bool bHighlight, float alphaFactor=1.0f);
  void drawTextForMarker(const ml::XMarker& marker, MLssize_t index, float vx, float vy, float vz, size_t i, View2DSlice* dslice, const ml::XMarkerList* markers, float * rgba );

  void updatePalette();
  virtual int getTimePoint(View2DSliceList* slicelist, int slice);
  void computeVoxelMinMaxZ(float& minz, float& maxz, const ml::XMarker& marker, View2DSliceList* slicelist);
  void getProjectedDeviceCoordinates(const ml::XMarker& marker, SbVec3f& voxelStartPosition, SbVec3f& voxelEndPosition, 
                                     float& deviceStartX, float& deviceStartY, float& deviceEndX, float& deviceEndY,
                                     int slice, View2DSliceList* slicelist);
  void getProjectedDeviceCoordinates(const ml::XMarker& marker, 
                                     float& deviceStartX, float& deviceStartY, float& deviceEndX, float& deviceEndY,
                                     int slice, View2DSliceList* slicelist);
  void getProjectedDeviceCoordinates(const SbVec3f& voxelStartPosition, const SbVec3f& voxelEndPosition, 
                                     float& deviceStartX, float& deviceStartY, float& deviceEndX, float& deviceEndY,
                                     int slice, View2DSliceList* slicelist);
  void getProjectedDeviceCoordinates(const SbVec3f& voxelPosition, float& deviceX, float& deviceY, int slice, View2DSliceList* slicelist);

  void convertMarkerVectorToVoxel(const ml::XMarker& marker, SbVec3f& voxelStartPosition, SbVec3f& voxelEndPosition, View2DSliceList* slicelist);
  GLushort getStipplePattern(GLint lineWidth);

protected:
  virtual ~SoView2DMarkerEditor();
};


#endif