SoCSOTransformEditor.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 <SoView2DCSOEditor/SoView2DCSOExtensibleEditor/SoCSOEditorExtension.h>

 
ML_START_NAMESPACE
class CSO;
ML_END_NAMESPACE


class SOCSO_EXPORT SoCSOTransformEditor : public SoCSOEditorExtension
{
  SO_NODE_HEADER(SoCSOTransformEditor);
 
public:

  SoCSOTransformEditor();
  ~SoCSOTransformEditor() override;

  void draw(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& drawSliceInfo, SoView2DCSOExtensibleEditor* editor) override;

  static void initClass();
 
  virtual bool evaluateHitPoint(const ml::Vector3& worldPosition, View2DSliceList* slicelist, ml::CSOList* csoList, ml::CSO*& cso,
                                SoView2DCSOExtensibleEditor* editor);
   bool evaluateHitPoint(const ml::Vector3& , View2DSliceList* , ml::CSOList* ,
    const ml::CSOBoundingBox& , SoView2DCSOExtensibleEditor* ,
    ml::CSO*& , ml::CSOSeedPoint*& ,
    ml::CSOPathPoints*& , float& ) override
  {
    return false;
  }
 
  bool isModificationEditor() const override { return true; }
  void cancel() override;

  bool isEligibleForTransforming(ml::CSO* cso, View2DSliceList* slicelist, SoView2DCSOExtensibleEditor* editor);
 
  void transformStartPressAt(const SoPointerPosition& pos);
  void transformDragMoveTo(const SoPointerPosition& pos);
 
  SoPointingAction* transformEndPress(int clickCount);
 
  void createStartPressAt(const SoPointerPosition& ) override {}
  void createDragMoveTo(const SoPointerPosition& ) override {}
  bool createEndPress(int ) override { return false; }
  void pointerPositionIfAllowedAt(const SoPointerPosition& ) override {}
 
  void selectAndMoveStartPressAt(const SoPointerPosition& ) override {}
  void selectAndMoveDragMoveTo(const SoPointerPosition& ) override {}
  SoPointingAction* selectAndMoveEndPress(int ) override { return nullptr; }
 
  int cursorShape() const override { return _cursorShape; }
 
  bool shouldRenderSpecific(ml::CSO*) const override { return false; }
  bool shouldRenderGeneral(ml::CSO*) const override { return true;  }
 
  SoSFBool hideHandlesWhileInteracting;
 
  SoSFBool allowScale;
  SoSFBool allowTranslation;
  SoSFBool allowRotation;
 
  SoSFFloat scaleHandleMargin;
  SoSFFloat translateHandleAreaSize;
 
  SoSFBool isotropicScaling;
 
  SoSFEnum defaultCursor;
  SoSFEnum moveAllCursor;
 
  SoSFEnum scaleNCursor;
  SoSFEnum scaleNWCursor;
  SoSFEnum scaleWCursor;
  SoSFEnum scaleSWCursor;
  SoSFEnum scaleSCursor;
  SoSFEnum scaleSECursor;
  SoSFEnum scaleECursor;
  SoSFEnum scaleNECursor;
 
  SoSFEnum rotateCursor;
 
protected:
 
  void drawInteractionHandleAsSeedPointAt(ml::CSO* cso, float deviceX, float deviceY);
 
  void initMembers() override;
 
private:

  enum ScaleDirection
  {
    UN = -1, 
    NW =  0, 
    N  =  1, 
    NE =  2, 
    W  =  3, 
    E  =  4, 
    SW =  5, 
    S  =  6, 
    SE =  7  
  };
 
  void performScaling(const SoPointerPosition &pos);
  void performRotation(const SoPointerPosition &pos);
  void performTranslation(const SoPointerPosition &pos);

  static void baseEventCB(void* userData, ml::BaseEvent* event);
  void attachAsListenerTo(ml::CSOList* csoList);
  ml::CSOList* _listenToCSOList;

  bool isInSelectionDistance(const SbVec2f& pos1, const SbVec2f& pos2, float selectionDistance) const;
  bool isInTranslationArea(const SbVec2f& mouseDevicePosition, const std::vector < SbVec2f >& translateHandlesPositions)const;
 

  void clearHandlesPositions();
  void setScaleCursorShape();
  void limitScaleOffset(SbVec2f& scaleOffset);
  void computeMoveAndScaleFactors(const SbVec3f& offsetX, const SbVec3f& offsetY, float voxelBBX, float voxelBBY,
                                  float& voxelMoveX, float& voxelMoveY, float& voxelScaleX, float& voxelScaleY) const;

  void computeMoveAndScaleFactorsForIsotropicScaling(const SbVec3f& bbVoxelCenterPoint, const SbVec3f& currentVoxelPosition, float& voxelScaleX, float& voxelScaleY);
  void drawRotateIndicatorLine(ml::CSO* cso, const SbVec2f& rotateHandlePosition, float rotateHandleOffset);
 
  boost::unordered_map < MatrixHashPair, std::vector < SbVec2f >, MatrixHashFunction > _scaleHandlesPositionsCache;
  boost::unordered_map < MatrixHashPair, std::vector < SbVec2f >, MatrixHashFunction > _translateHandlesPositionsCache;
 
  boost::unordered_map < MatrixHashPair, SbVec2f, MatrixHashFunction > _rotateHandlePositionCache;
  boost::unordered_map < MatrixHashPair, SbVec2f, MatrixHashFunction > _rotateCenterCache;

  void resetActiveHandleIndices()
  {
    _activeScaleHandleIndex = -1;
    _activeTranslateHandleIndex = -1;
    _activeRotateHandleIndex = -1;
  }

  bool shouldShowHandles() const;
 
  bool _isInteracting;
  bool _isRotating;
 
  int _activeScaleHandleIndex;
  int _activeTranslateHandleIndex;
  int _activeRotateHandleIndex;
 
  SbVec2f _startDevicePosition;
  SbVec3f _startVoxelPositionForIsotropicScaling;
  SbVec3f _lastWorldPosition;
  SbVec3f _lastGoodCurrentWorldPosition;
 
  int _cursorShape;
 
  ml::CSO _originalCSO;
 
  SbVec2f _rotationCenterDevice;
  void setRotationCenter(View2DSliceList* slicelist);
  ml::Matrix4 composeMLRotationMatrix(const SoPointerPosition& pos);
 
  ml::Matrix4 convertInventorToMLMatrix(const SbMatrix& matrix);
 
  ml::CSO* _selectedCSO;
};