SoCoordinateSystem.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2021, 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 <ThirdPartyWarningsDisable.h>
 
#include <Inventor/nodes/SoShape.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/fields/SoSFVec3f.h>
#include <Inventor/fields/SoSFFloat.h>
#include <Inventor/fields/SoSFDouble.h>
#include <Inventor/fields/SoSFColor.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/fields/SoSFNode.h>
 
#include <SoSFMLImage.h>
#include <SoSFMLBase.h>
 
#include <ThirdPartyWarningsRestore.h>
 
#include <sstream>
#include <iostream>
 
namespace
{
 
  inline float sign(float number)
  {
    return (number < 0) ? -1.f : 1.f;
  }
 
}
 
struct CoordinateAxis
{
  CoordinateAxis(const SbVec3f& worldStart, const SbVec3f& worldEnd, const std::string& label, int logicalDirection) :
    label(label),
    logicalDirection(logicalDirection)
  {
    isMaxPointingToScreenZ = false;
 
    setWorldPositions(worldStart, worldEnd);
  }
 
  void setWorldPositions(const SbVec3f& start, const SbVec3f& end)
  {
    worldStart = start;
    worldEnd = end;
    worldDirection = end - start;
    worldLength = worldDirection.length();
    worldDirection.normalize();
 
    renderLengthForArrowPlacement = worldLength;
  }
 
  void setScreenPositions(const SbVec3f& start, const SbVec3f& end)
  {
    screenStart = start;
    screenEnd = end;
    screenDirection = end - start;
    screenDirection.normalize();
  }
 
  std::string label;
 
  int logicalDirection;
 
  SbVec3f worldStart;
  SbVec3f worldEnd;
  SbVec3f worldDirection;
  float worldLength;
 
  SbVec3f screenStart;
  SbVec3f screenEnd;
  SbVec3f screenDirection;
 
  SbVec3f tickDirection;
  SbVec2f textScreenShift;
 
  float renderLengthForArrowPlacement;
  bool isMaxPointingToScreenZ;
};
 
struct LabelText
{
  LabelText()
  {
    fontSize = 10.f;
    textColor.setValue(1, 1, 1);
    textAlpha = 1.f;
    useTextShadow = true;
    textShadowColor.setValue(0, 0, 0);
  }
 
  std::string text;
 
  SbVec3f textPosition;
  SbVec2f textShiftFactorScreen;
 
  float fontSize;
 
  SbColor textColor;
  float textAlpha;
 
  bool useTextShadow;
  SbColor textShadowColor;
};
 
struct Label
{
  Label()
  {
    initializeScreenBoundingBox();
  }
 
  void initializeScreenBoundingBox()
  {
    screenBoundingBox[0].setValue(FLT_MAX, FLT_MAX);
    screenBoundingBox[1].setValue(FLT_MAX, FLT_MAX);
    isVisible = true;
    isOnScreen = false;
  }
 
  bool overlaps(const Label& otherLabel) const
  {
    const auto margin = 3.0f;
 
    const auto ax0 = screenBoundingBox[0][0] - margin;
    const auto ay0 = screenBoundingBox[0][1] - margin;
    const auto ax1 = screenBoundingBox[1][0] + margin;
    const auto ay1 = screenBoundingBox[1][1] + margin;
 
    const auto bx0 = otherLabel.screenBoundingBox[0][0] - margin;
    const auto by0 = otherLabel.screenBoundingBox[0][1] - margin;
    const auto bx1 = otherLabel.screenBoundingBox[1][0] + margin;
    const auto by1 = otherLabel.screenBoundingBox[1][1] + margin;
 
    const auto awidth = abs(ax0 - ax1);
    const auto aheight = abs(ay0 - ay1);
 
    const auto bwidth = abs(bx0 - bx1);
    const auto bheight = abs(by0 - by1);
 
    return (abs((ax0 + awidth / 2) - (bx0 + bwidth / 2)) * 2 < (awidth + bwidth)) &&
      (abs((ay0 + aheight / 2) - (by0 + bheight / 2)) * 2 < (aheight + bheight));
  }
 
  SbVec3f tickPosition;
  SbVec3f tickDirection;
  SbColor tickColor;
  float tickAlpha;
 
  SbVec2f screenBoundingBox[2];
  bool isVisible;
  bool isOnScreen;
 
  LabelText labelText;
};
 
class SoCoordinateSystem : public SoShape
{
  SO_NODE_HEADER(SoCoordinateSystem);
 
public:
 
  static void initClass();
 
  SoCoordinateSystem();
 
  enum StrideMode
  {
    AUTO = 0,
    USER = 1
  };
 
  enum EndTickMode
  {
    ROUND_UP      = 0,
    ROUND_DOWN    = 1,
    ROUND_NEAREST = 2,
    PRECISE       = 3
  };
 
  enum UserTransformMode
  {
    NO_USER_TRANSFORM = 0,
    USER_TRANSFORM_INSTEAD_OF_INPUT = 1,
    APPLY_USER_TRANSFORM_TO_INPUT = 2
  };
 
  SoSFTypedEnum<StrideMode> strideMode;
  SoSFDouble userStride;
 
  SoSFTypedEnum<EndTickMode> endTickMode;
 
  SoSFColor axisColor;
  SoSFFloat axisAlpha;
 
  SoSFColor tickColor;
  SoSFFloat tickAlpha;
 
  SoSFColor numbersFontColor;
  SoSFFloat numbersFontAlpha;
 
  SoSFColor lettersFontColor;
  SoSFFloat lettersFontAlpha;
  SoSFFloat lettersFontSizeOffset;
 
  SoSFBool useTextShadow;
  SoSFColor textShadowColor;
 
  SoSFFloat fontSize;
 
  SoSFFloat arrowLengthFactor;
  SoSFFloat letterOffsetFactor;
  SoSFBool useVoxelAlignedBoundingBox;
 
  SoSFMLImage inImage;
  SoSFNode inNode;
  SoSFVec3f userScale;
  SoSFVec3f userTranslate;
  SoSFTypedEnum<UserTransformMode> userTransformMode;
 
protected:
 
  ~SoCoordinateSystem() override;
 
private:
  std::vector<CoordinateAxis> axes;
  int _maxZAxisIndex;
 
  void initializeAxes();
  void applyUserTransform();
 
  void computeScreenCoordinates(CoordinateAxis& axis);
  void computeAndSetTickDirections();
  SbVec2f computeTextShiftFactorVector(int axisIndex);
  float computeTextShiftFactor(float angle0, float angle1);
  void computeAndSetLabelVisibility(std::vector<Label>& labels);
 
  float getTickScale();
  int getEndTickModifier(int numTicks, float length);
 
  double getStride();
  double getAutoStride(float maxRange);
  double getUserStride(float maxRange);
  float getMaxAxisRange();
 
  bool anyLabelOverlap(const std::vector<Label>& labels);
  void generatePrimitives(SoAction *) override {}
 
  void GLRender(SoGLRenderAction *action) override;
  void glRenderTicks();
  void glRenderAxisLines();
  void glRenderOrigin();
 
  void computeBBox(SoAction *action, SbBox3f &box, SbVec3f &center) override;
 
 
  void updateAxes(SoField*);
 
  void updateFromInputInventorScene();
  void updateFromInputImage();
 
  SbVec3f getImageExtent();
  SbMatrix getImageVoxelToWorldMatrix();
  float getScaleForLogicalDirection(const CoordinateAxis& axis);
 
  void message(const std::string& messageText) const
  {
    std::cout << messageText << std::endl;
  }
};