SoCSOEditorTools.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2012, 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 <CSOBase/CSOBoundingBox.h>
#include <mlLinearAlgebra.h>
#include <SoCSODefines.h>
 
 
class View2DSliceList;
class SoCSOTransform;
class SoView2DCSOExtensibleEditor;
 
namespace ml
{
  class CSO;
  class CSOVisualizationSettings;
}
 
namespace SoCSOEditorTools
{
  enum RelativeSlicePosition
  {
    SLICE_BELOW = 0,
    SLICE_IN    = 1,
    SLICE_ABOVE = 2
  };
 
  struct PathPointSlicePosition
  {
    ml::Vector3 position;
    RelativeSlicePosition slicePosition;
  };
 
  struct ImageStatisticsForCSO
  {
    unsigned int csoID;
 
    MLuint64 numVoxels;
    MLdouble imageMinValue;
    MLdouble imageMaxValue;
    MLdouble imageMeanValue;
    MLdouble imageAbsMeanValue;
    MLdouble imageVarianceValue;
    MLdouble imageStdDeviationValue;
    MLdouble imageAverageSquaredSumValue;
    MLdouble imageSumValue;
 
    std::string imageModality;
    MLdouble imageRescaleIntercept;
    MLdouble imageRescaleSlope;
  };
 
  struct PathPointsSegment
  {
    ml::Vector3 startPosition;
    ml::Vector3 endPosition;
  };
 
  struct vectorXSort
  {
    bool operator ()(const ml::Vector2& a, const ml::Vector2& b) const
    {
      return a[0] < b[0];
    }
  };
 
  struct LineRenderSettings
  {
    LineRenderSettings() : shouldUseAntiAliasing(true), stipplePattern(0xffff), width(1.0f), alpha(1.0f), outlineAlpha(1.0f) {}
 
    bool shouldUseStippling() const { return stipplePattern != 0xffff; }
    bool shouldUseAntiAliasing;
    unsigned short stipplePattern;
    float width;
 
    SbColor color;
    float alpha;
 
    SbColor outlineColor;
    float outlineAlpha;
  };
 
 
  ImageStatisticsForCSO performImageStatistics(ml::CSO* cso, SoSFMLImage* image);
  void setStatisticsToUserData(ml::CSO* cso, const ImageStatisticsForCSO& statistics, const std::string& viewerIdentifier="");
 
  void setUserDataWithViewerId(ml::CSO* cso, const std::string& userDataName, const std::string& viewerIdentifier, const ml::Variant& value);
 
  void fillCrossingsVector(std::vector< std::vector< ml::Vector2 > >& crossingsVector,
                           const std::vector< ml::Vector3 >& pathPoints,
                           const ml::Vector3& minBB, const ml::Vector3& maxBB);
 
  void retrieveDicomTagData(SoSFMLImage* image, std::string& modality, float& rescaleIntercept, float& rescaleSlope);
 
 
  ml::CSOBoundingBox computeSlabBoundingBox(float deviceX, float deviceY, View2DSliceList* slicelist);
  ml::CSOBoundingBox computeSlabBoundingBox(int voxelZ, View2DSliceList* slicelist, int voxelAugmentInZ=0);
  bool isOnCurrentSlice(SoView2DCSOExtensibleEditor* editor, const CSODrawCSOInfos& csoDrawInfos, const CSODrawView2DInfos& view2DInfos);
  bool isOnCurrentSlice(ml::CSO* cso, const CSODrawView2DInfos& view2DInfos);
  bool isOnCurrentSlice(ml::CSO* cso, View2DSliceList* slicelist, const ml::Vector3& sliceNormalWorld, SoCSOTransform* csoTransform);
  float getParallelThicknessAbsoluteValue(View2DSliceList* slicelist, ml::CSOVisualizationSettings* vSettings);
  bool isApproximatelyParallel(ml::CSO*cso, View2DSliceList* slicelist, float epsilon=-1);
  void fillWorldSliceCrossings(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos,
                               std::vector<CSOSliceCrossing>& belowSlicePositions,
                               std::vector<CSOSliceCrossing>& inSlicePositions,
                               std::vector<CSOSliceCrossing>& aboveSlicePositions);
  void getWorldSlicePlanes(const CSODrawView2DInfos& view2DInfos, ml::Plane& topPlane, ml::Plane& bottomPlane);
 
  void fillCrossingsOnePlaneCrossed(const ml::Plane& plane, const ml::Vector3& lastPosition, const ml::Vector3& currentPosition,
                                    CSOSliceCrossing& sliceCrossings, std::vector<CSOSliceCrossing>* crossings[3],
                                    int lastSlicePosition);
  void fillCrossingsBothPlanesCrossed(const ml::Plane& topPlane, const ml::Plane& bottomPlane,
                                      const ml::Vector3& lastPosition, const ml::Vector3& currentPosition, int relativePosition,
                                      CSOSliceCrossing &sliceCrossings, std::vector<CSOSliceCrossing>* crossings[3]);
 
  void fillWorldToVoxelMatrix(const CSODrawView2DInfos& view2DInfos, ml::Matrix4& worldToVoxelMatrix);
  void fillWorldToVoxelMatrix(const SoPointerPosition& pos, ml::Matrix4& worldToVoxelMatrix);
  void fillWorldToVoxelMatrix(View2DSliceList* sliceList, ml::Matrix4& worldToVoxelMatrix);
  void fillWorldToVoxelMatrix(const SbMatrix& inventorMatrix, ml::Matrix4& worldToVoxelMatrix);
 
  void fillVoxelToWorldMatrix(const CSODrawView2DInfos& view2DInfos, ml::Matrix4& voxelToWorldMatrix);
  void fillVoxelToWorldMatrix(const SoPointerPosition& pos, ml::Matrix4& voxelToWorldMatrix);
  void fillVoxelToWorldMatrix(View2DSliceList* sliceList, ml::Matrix4& voxelToWorldMatrix);
  void fillVoxelToWorldMatrix(const SbMatrix& inventorMatrix, ml::Matrix4& voxelToWorldMatrix);
 
  bool isAbovePlane(const ml::Vector3& worldPosition, const ml::Plane& plane);
  bool evaluateHitPoint(const ml::Vector3& worldPosition, View2DSliceList* slicelist, ml::CSOList* csoList,
                        const ml::CSOBoundingBox& slabBB, const std::string& subType, SoView2DCSOExtensibleEditor* editor,
                        bool testSeedPoints,
                        ml::CSO*& localHitCSO, ml::CSOSeedPoint*& localHitSeedPoint,
                        ml::CSOPathPoints*& localHitPathPoints, float& distanceToCSO);
 
  bool isEligibleForPicking(ml::CSO* cso, ml::CSOList* csoList, const std::string& subType, View2DSliceList* slicelist, SoView2DCSOExtensibleEditor* editor);
  bool hasTransformation(ml::CSO* cso, SoView2D* viewer, SoView2DCSOExtensibleEditor* editor);
  bool isInteractionAllowedBecauseOfRegistration(ml::CSO* cso, SoView2D* viewer, SoView2DCSOExtensibleEditor* editor);
  bool shouldRenderCSODependingOnImageCreation(ml::CSO* cso, SoView2DCSOExtensibleEditor* editor, View2DSliceList* slicelist);
  float getSquaredDeviceDistance(const ml::Vector3& worldPosition, View2DSliceList* slicelist, float dMouseX, float dMouseY);
  void mapWorldToDevice(View2DSliceList* slicelist, const ml::Vector3& worldPosition, float& devX, float& devY);
  float getSquaredDeviceLineDistance(const ml::Vector3& lineWorldStart, const ml::Vector3& lineWorldEnd, View2DSliceList* slicelist, float dMouseX, float dMouseY);
  bool isOnSameSlab(const ml::CSOBoundingBox& slabBB, const ml::CSOBoundingBox& csoBB);
  bool intersectsSlice(const ml::CSOBoundingBox& slabBB, const CSOVoxelSlab& csoBB);
  bool areOnSamePlane(ml::CSO* cso1, ml::CSO* cso2, float epsilon=0.00001f);
  bool areOnSamePlane(ml::CSO* cso, const ml::Vector3& position, const ml::Vector3& normal, float epsilon=0.00001f);
 
  void drawLines(GLint lineMode, const std::vector<ml::Vector3>& positions,
                 const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos,
                 const SbVec2f& deviceOffset);
 
  void getRightmostSeedPointPosition(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, float& deviceX, float& deviceY);
  void getRightMostPathPointPositionOnCurrentSlice(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, float& deviceX, float& deviceY);
  void getRightmostSeedPointPositionAndVector(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, float& deviceX, float& deviceY, float& deviceVX, float& deviceVY);
  SbVec2f convertDevicePositionToRelativeViewerPosition(View2DSlice* slice, const SbVec2f& deviceVector);
  SbVec2f convertRelativeViewerPositionToDevicePosition(View2DSlice* slice, const SbVec2f& relativeVector);
 
  bool mapWorldToDeviceViaVoxel(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos,
                                const ml::Vector3& position, float& deviceX, float& deviceY);
 
  void setupGLAntiAlias(bool shouldUseAntiAliasing);
  void restoreGLAntiAlias();
 
  bool enableGLStipplingIfNeeded(unsigned short pattern);
 
  bool isNearDeviceBoundingBox(View2DSliceList* slicelist, const ml::CSOBoundingBox &box, float selectionDistance, float dMouseX, float dMouseY);
 
  static std::vector<float> _lineBuffer;
}