SoView2DAnnotation.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 "SoView2DInteractionExtension.h"
 
#include <Inventor/fields/SoSFString.h>
#include <Inventor/fields/SoSFFloat.h>
#include <Inventor/fields/SoSFDouble.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/fields/SoSFInt32.h>
#include <Inventor/fields/SoSFNode.h>
#include <Inventor/nodes/SoSeparator.h>
#include <DCMTree_Tag.h>
#include <unordered_map>
 
class SoView2D;
class View2DFont;
class SoOrthographicCamera;
class SoMatrixTransform;
class SoDirectionalLight;
 
// Constant name definitions
 
enum AnnotationMode {
    ANNO_MODE_USER,
    ANNO_MODE_CT,
    ANNO_MODE_MR,
    ANNO_MODE_AUTO
};
 
enum AnnotationShowMode {
    ANNO_SHOW_HIDE = 0,
    ANNO_SHOW_SHORT = 1,
    ANNO_SHOW_DETAILED = 2
};
 
enum AnnotationFontSize {
    ANNO_SIZE_AUTO = -1,
    ANNO_SIZE_SMALL = 0,
    ANNO_SIZE_MEDIUM = 1,
    ANNO_SIZE_LARGE = 2,
    ANNO_SIZE_USER = 3
};
 
enum AnnotationOrientationMode {
    ANNO_ORIENTATION_OFF,
    ANNO_ORIENTATION_SIZE_FIXED,
    ANNO_ORIENTATION_SIZE_WEIGHTED
};
 
enum AnnotationOrientionModelPosition {
  ANNO_TOP_LEFT,
  ANNO_TOP_RIGHT,
  ANNO_BOTTOM_LEFT,
  ANNO_BOTTOM_RIGHT
};
 
struct LastViewerInfo
{
  LastViewerInfo()
  {
    spaceX = -1;
    spaceY = -1;
    lastFontSize = -1;
    hasFoundFontSizeLastTime = false;
    lastSetAnnotationMode = ANNO_SHOW_DETAILED;
    lastDetail = ANNO_SHOW_DETAILED;
  }
  int spaceX;
  int spaceY;
  int lastFontSize;
  bool hasFoundFontSizeLastTime;
  int lastSetAnnotationMode;
  int lastDetail;
};
 
struct PixelBoundingBox
{
  int minx;
  int maxx;
  int miny;
  int maxy;
};
 
//-------------------------------------------------------------------------
 
class SOVIEW2D_API SoView2DAnnotation : public SoView2DInteractionExtension
{
  SO_NODE_HEADER(SoView2DAnnotation);
 
public:
 
  enum AlignPosition {
    TOP_LEFT,
    TOP_RIGHT,
    BOTTOM_LEFT,
    BOTTOM_RIGHT,
    BOTTOM_CENTER,
    CENTER_CENTER
  };
 
 
  SoSFString annotationUserTopLeft;
  SoSFString annotationUserTopRight;
  SoSFString annotationUserBottomLeft;
  SoSFString annotationUserBottomRight;
  SoSFString annotationUserBottomCenter;
 
  SoSFString annotationCTTopLeft;
  SoSFString annotationCTTopRight;
  SoSFString annotationCTBottomLeft;
  SoSFString annotationCTBottomRight;
  SoSFString annotationCTBottomCenter;
 
  SoSFString annotationMRTopLeft;
  SoSFString annotationMRTopRight;
  SoSFString annotationMRBottomLeft;
  SoSFString annotationMRBottomRight;
  SoSFString annotationMRBottomCenter;
 
  SoSFString shortTopLeft;
  SoSFString shortTopRight;
  SoSFString shortBottomLeft;
  SoSFString shortBottomRight;
  SoSFString shortBottomCenter;
 
  SoSFInt32  minDetailFontSize;
  SoSFInt32  maxDetailFontSize;
  SoSFInt32  minShortFontSize;
  SoSFInt32  maxShortFontSize;
  SoSFInt32  userDetailFontSize;
  SoSFInt32  userShortFontSize;
 
  SoSFInt32 rulerFontSize;
 
  SoSFEnum   annotationMode;
  SoSFEnum   showAnnotation;
  SoSFEnum   annotationFontSize;
  SoSFBool   textShadow;
  SoSFColor  textShadowColor;
  SoSFBool   rulerShadow;
  // new fields to influence font selection:
  SoSFString fontWidthDummyString; // fit this string into the target width instead of the real width if != ""
  SoSFInt32  targetWidth;          // assume this to be the target width if != 0
  SoSFInt32  targetHeight;         // assume this to be the target height if != 0
 
  SoSFInt32  marginTop;
  SoSFInt32  marginLeft;
  SoSFInt32  marginBottom;
  SoSFInt32  marginRight;
 
  SoSFInt32  abreviateChars;
  SoSFInt32  abreviateShortChars;
 
  SoSFEnum   showOrientation;
  SoSFBool   drawNegativeOrientation;
  SoSFBool   drawPositiveOrientation;
  SoSFColor  orientationColor;
 
  SoSFBool   verticalRuler;
  SoSFBool   horizontalRuler;
  SoSFInt32  verticalRulerMarginRight;
  SoSFInt32  horizontalRulerMarginBottom;
 
  SoSFBool   orientationModel;
  SoSFEnum   orientationModelPosition;
  SoSFFloat  orientationModelRelativeSize;
  SoSFInt32  orientationModelMinSize;
  SoSFInt32  orientationModelMaxSize;
  SoSFFloat  orientationModelRelativeVerticalOffset;
  SoSFInt32  orientationModelMinVerticalOffset;
  SoSFInt32  orientationModelMaxVerticalOffset;
  SoSFFloat  orientationModelRelativeHorizontalOffset;
  SoSFInt32  orientationModelMinHorizontalOffset;
  SoSFInt32  orientationModelMaxHorizontalOffset;
 
  SoSFColor  orientationModelColor;
 
  SoSFBool   showTechnicalInfo;
 
  SoSFString input00;
  SoSFString input01;
  SoSFString input02;
  SoSFString input03;
  SoSFString input04;
  SoSFString input05;
  SoSFString input06;
  SoSFString input07;
  SoSFString input08;
  SoSFString input09;
 
  SoSFDouble numInput00;
  SoSFDouble numInput01;
  SoSFDouble numInput02;
  SoSFDouble numInput03;
  SoSFDouble numInput04;
  SoSFDouble numInput05;
  SoSFDouble numInput06;
  SoSFDouble numInput07;
  SoSFDouble numInput08;
  SoSFDouble numInput09;
 
  // field for definition of background box
  SoSFBool   drawBackgroundBox;
  SoSFColor  backgroundColor;
  SoSFFloat  backgroundOpacity;
  SoSFColor  backgroundEdgeColor;
  SoSFFloat  backgroundEdgeOpacity;
 
  SoSFNode   inOrientationModel;
 
  SoSFBool isMouseOverCube;
  SoSFString hitOrientationLetter;
 
  SoSFBool   orientationAndScaleFromCamera;
 
  static void   initClass();
 
  SoView2DAnnotation();
 
  ~SoView2DAnnotation() override;
 
  void   draw(View2DSliceList *dsl, View2DSlice* dslice, int slice) override;
 
  bool   evalEvent(SoView2D* view2d, View2DSliceList* slicelist,
                   View2DEvent* ec, View2DEventPhase phase) override;
 
  void toggleAnnotation();
  void toggleTechnicalInfo();
 
  void parseString(View2DSliceList* list,View2DSlice* slice, const SbString &string , SbString &resultString, int limitToChars = -1);
 
  void drawAnnotation(const char* string, const PixelBoundingBox& pixelBoundingBox,
                      int fontsize, AlignPosition pos, bool shouldDrawBox,
                      int& outBoxWidth, int& outBoxHeight);
 
  float decimalFloor(float number, SbString& result, int &divider);
 
  void drawVerticalRuler(View2DSliceList* dsl, View2DSlice* dslice, bool drawText, int marginRight, const PixelBoundingBox& pixelBoundingBox);
  void drawHorizontalRuler(View2DSliceList* dsl, View2DSlice* dslice, bool drawText, int marginBottom, const PixelBoundingBox& pixelBoundingBox);
 
  virtual bool drawVerticalRulerTextBelow() const { return false; }
 
  static void getExtOrientation (int axis, SbMatrix &matrix, float *orWeights,
                                 char *negOrientation, char *posOrientation);
 
  void drawOrientation (const char *string, float posX, float posY, float fontSize,
                               View2DFont* font, float relOffX, float relOffY, float *orWeights);
 
  static SbVec2f getTargetSizeInScene (SoNode* scene, int width, int height);
 
  struct Margins {
    Margins() {
      top = 0; bottom = 0; left = 0; right = 0;
    }
    Margins(int value) {
      top = value; bottom = value; left = value; right = value;
    }
    Margins(int top, int right, int bottom, int left) {
      this->top = top;
      this->right = right;
      this->bottom = bottom;
      this->left = left;
    }
    Margins &operator *=(int value) {
      top *= value; bottom *= value; left *= value; right *= value;
      return *this;
    }
 
    int top;
    int bottom;
    int left;
    int right;
  };
 
  virtual Margins calculateTextMargins(int width, int height);
 
  virtual Margins calculateCenterTextMargins(int width, int height);
 
  virtual int calculateOrientationModelSize(int width, int height);
 
  virtual int calculateOrientationModelOffset(int viewSize, const SoSFFloat& relativeOffset,
      const SoSFInt32& minOffsetPixels, const SoSFInt32& maxOffsetPixels);
 
  SbMatrix calculateOrientationModelRotationMatrix(View2DSlice* slice);
 
  virtual void drawOrientationCube(const SbMatrix &rotationMatrix, int posX, int posY, int modelSize);
 
  virtual void drawAndStoreCubePolygon(char letter, const SbMatrix& rotationMatrix, int posX, int posY, int modelSize, int pass,
    const SbVec3f& pos0, const SbVec3f& pos1, const SbVec3f& pos2, const SbVec3f& pos3);
 
  virtual void drawOrientationModelUsingInventor(SoAction* action, const SbMatrix &rotationMatrix, int posX, int posY, int modelSize);
 
  virtual void drawOrientationCubeLetter(char letter, int modelSize, bool shadowPass);
 
  virtual bool implementsManagedInteraction() const { return true; }
 
  bool implementsManagedInteractionAndClassicEventHandling() const override { return true; }
 
  bool isSensitiveAt(const SoPointerPosition& pos) override;
  void startPressAt(const SoPointerPosition& pos) override;
  void dragMoveTo(const SoPointerPosition& pos) override;
  SoPointingAction* endPress(int clickCount) override;
 
 
protected:
  virtual SbString restrict(const SbString& value, int maxLength) const;
 
  virtual SbString asString(int value) const;
  virtual SbString asString(double value, int precision) const;
 
  virtual SbString getDicomTagValueAsString(DCMTree::Const_TagPtr tagPtr, unsigned int index, unsigned int precision) const;
 
  void editingOnChanged(SoField* field) override;
 
  virtual void clearViewerCache(SoField* field) { _lastViewerInfoCache.clear(); }
 
private:
  SoSFString* _inputs[10];
  SoSFDouble* _numInputs[10];
 
  long  _lastEventSecs;
  long  _lastEventUSecs;
 
  float _FLT_M_PI;
 
  void clearLastViewerInfoCache(SoField* field) { _lastViewerInfoCache.clear(); }
 
  std::unordered_map<void*, LastViewerInfo> _lastViewerInfoCache;
 
  struct OrientationCubePolygon
  {
    SbVec2f positions[4];
    char orientationLetter;
  };
 
  std::vector < OrientationCubePolygon > _orientationCubePolygons;
 
  bool isPointInPolygon(const SbVec2f& point, const SbVec2f& polygon0, const SbVec2f& polygon1, const SbVec2f& polygon2, const SbVec2f& polygon3);
  bool isSameSide(const SbVec2f& point0, const SbVec2f& point1, const SbVec2f& line0, const SbVec2f& line1) const;
  bool isOverOrientationCube(const SbVec2f& position) { char letter; return isOverOrientationCube(position, letter); }
  bool isOverOrientationCube(const SbVec2f& position, char& letter);
 
  void _drawOrientationLetters(View2DSliceList* dsl, View2DSlice* dslice);
  void _drawAnnotationStrings(SbString * resultString, const PixelBoundingBox& pixelBoundingBox, const PixelBoundingBox& centerBoundingBox, int fontsize, int annotationBoxSize[5][2]);
  void _drawTechnicalInfo(View2DSliceList * dsl, View2DSlice* dslice, const PixelBoundingBox& pixelBoundingBox);
  void _drawRulers(View2DSliceList * dsl, View2DSlice* dslice, const PixelBoundingBox& pixelBoundingBox);
  void _drawOrientationModel(View2DSliceList * dsl, View2DSlice* dslice, const PixelBoundingBox& pixelBoundingBox, int  annotationBoxSize[5][2]);
 
  int _getDefaultFontSize(int fontsize, int userfontsize);
  bool _findFontSizeAndDetailLevel(View2DSliceList * dsl, View2DSlice* dslice, int& fontSize, const PixelBoundingBox& pixelBoundingBox, const PixelBoundingBox& centerBoundingBox, SbString* resultString, const SbString& topLeft, const SbString& topRight, const SbString& bottomLeft, const SbString& bottomRight, const SbString& bottomCenter);
  bool _findFittingFontSize(int& fontsize, const PixelBoundingBox& pixelBoundingBox, const PixelBoundingBox& centerBoundingBox, int minfontsize, int maxfontsize, SbString * resultString);
  void _fillPixelBoundingBoxes(View2DSlice* dslice, PixelBoundingBox &pixelBoundingBox, PixelBoundingBox &centerBoundingBox);
  bool _isRulerSupported(View2DSliceList * dsl);
  int _getAnnotationMode(View2DSliceList * dsl) const;
  void _fillCornerStringsDependingOnAnnotationMode(View2DSliceList * dsl, SbString &topLeft, SbString &topRight, SbString &bottomLeft, SbString &bottomRight, SbString &bottomCenter);
 
  bool _heightFits(int h1, int h2, int h3, int h4, int h5, int tHeight, int ctHeight) const { return (h1 + h3 <= tHeight) && (h2 + h4 <= tHeight) && (h5 <= ctHeight); }
  bool _dummyStringFitsIntoWidth(bool useDummyString, int w0, int tWidth) const { return useDummyString && (w0 < tWidth); }
  bool _actualTextFitsIntoWidth(bool useDummyString, int w1, int w2, int w3, int w4, int w5, int tWidth, int ctWidth) const { return !useDummyString && (w1 + w2 <= tWidth) && (w3 + w4 <= tWidth) && (w5 <= ctWidth); }
 
  static SbString getStringForChar(char c) { return SbString(std::string(1,c).c_str()); }
 
  SoRef<SoSeparator>    _orientationModelScene;
  SoSeparator*          _orientationModelInnerScene;
  SoOrthographicCamera* _orientationModelCamera;
  SoDirectionalLight*   _orientationModelHeadlight;
 
  SoCommandAction* _toggleAnnotationAction;
  SoCommandAction* _toggleTechnicalInfoAction;
};