SoView2DRigidRegistrationEditorBase.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2013, 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
**
**************************************************************************************/
 
// editor for setting a rigid registration
 
#pragma once
 
#include "SoView2DInteractionExtension.h"
 
// Wrap inventor includes into XVEnterScope and XVLeaveScope to avoid
// collisions between OpenInventor and Windows headers.
#include "XVEnterScope.h"
#include <Inventor/nodes/SoSubNode.h>
#include <View2DSlice.h>
#include <View2DSliceList.h>
#include <View2DIcons.h>
// include used fields
#include <Inventor/fields/SoSFTrigger.h>
#include <Inventor/fields/SoSFVec3f.h>
#include <Inventor/fields/SoSFColor.h>
#include <Inventor/fields/SoSFMatrix.h>
#include <Inventor/sensors/SoFieldSensor.h>
#include <Inventor/sensors/SoNodeSensor.h>
#include <Inventor/SbLinear.h>
#include "XVLeaveScope.h"
 
 
 
 
class SOVIEW2D_API SoView2DRigidRegistrationEditorBase : public SoView2DInteractionExtension
{
  SO_NODE_ABSTRACT_HEADER(SoView2DRigidRegistrationEditorBase);
 
public:
  SoView2DRigidRegistrationEditorBase(const std::string& actionID);
 
  static void  initClass();
 
  void draw(View2DSliceList *list, View2DSlice *slice, int z) override;
 
  SoSFMatrix  outputMatrix;
 
  SoSFVec3f   rotationCenterWorld;
 
  SoSFMatrix  defaultOutputMatrix;
 
  SoSFTrigger reset;
  SoSFTrigger resetRotationWheelCenter;
 
  SoSFString  resolvedWheelImageFile;
  SoSFString  resolvedCenterImageFile;
 
  SoSFFloat   rotationRelativeCenterRadius;
  SoSFFloat   minRelativeWheelRadius;
  SoSFFloat   maxRelativeWheelRadius;
 
  SoSFColor   inactiveColor;
  SoSFColor   highlightColor;
  SoSFBool    drawShadow;
  SoSFColor   shadowColor;
  SoSFFloat   alpha;
 
  SoSFFloat   sizeViewerPercentage;
  SoSFFloat   minWheelSizeInPixels;
  SoSFFloat   maxWheelSizeInPixels;
 
  virtual void doReset();
 
protected:
  ~SoView2DRigidRegistrationEditorBase() override;
 
  bool implementsManagedInteractionAndClassicEventHandling() const override { return false; }
 
  bool isSensitiveAt(const SoPointerPosition&) override;
  int getCurrentCursor(SoViewerProxy* viewerProxy) override;
  void setHighlightAt(const SoPointerPosition& pos) override;
  void unsetHighlight() override;
  void startPressAt(const SoPointerPosition& pos) override;
  void dragMoveTo(const SoPointerPosition& pos) override;
  SoPointingAction* endPress(int clickCount) override;
 
  void doResetCallback(SoField*) { doReset(); }
  void doResetRotationWheelCenterCallback(SoField*) { _calcRotationCenter = true; }
  virtual void iconImagesChanged(SoField*) { _initializeImages(); }
 
  void pointerPosition(const SoPointerPosition& pos) override;
  void pointerLeftWindow() override;
 
  struct RegistrationState
  {
    RegistrationState() {}
    RegistrationState(SbMatrix aMatrix, SbVec3f aCenter) : matrix(aMatrix), center(aCenter) {}
 
    SbMatrix matrix;
    SbVec3f center;
  };
 
  virtual void pushOldState(const RegistrationState& /*state*/) {}
 
  bool getRegistrationState(RegistrationState& state) const;
  void setRegistrationState(const RegistrationState& state);
 
private:
  using SoView2DInteractionExtension::pointerPosition;
  using SoView2DInteractionExtension::pointerLeftWindow;
 
  enum Part {
    OtherPart,
    RotationCenter,
    RotationWheel
  };
 
  void _startDrag(const SbVec3f& voxelPos);
  void _dragTo(View2DSliceList* sliceList, const SbVec3f& voxelPos);
  void _endDrag();
 
  bool _pointerInViewer;
 
  bool _isDragging;
 
  void _drawIconAt(int index, const SbVec2f& p0, const SbVec2f& d1, const SbVec2f& d2, float size);
 
  void _drawTexture(View2DTexture* texture, const SbVec2f& p0, const SbVec2f& p1, const SbVec2f& p2);
 
  Part _getPart(View2DSlice *slice, const SbVec3f& worldPos) const;
 
  float _getWidgetSize(View2DSlice *slice) const;
 
  void _initializeImages();
 
  void _setUndoEnabled(bool enabled);
  void _setRedoEnabled(bool enabled);
 
  View2DIcons* _images;
 
  View2DSlice* _currentInteractionSlice;
 
  SbVec3f _startingPointWorld;
 
  RegistrationState _startingState;
 
  Part _currentPart;
 
  bool _calcRotationCenter;
 
  class CommandAction : public SoCommandAction
  {
  public:
    CommandAction(SoView2DRigidRegistrationEditorBase* owner, const std::string& id) : SoCommandAction(owner, id) {}
 
    inline SoView2DRigidRegistrationEditorBase* getWidget() const { return static_cast<SoView2DRigidRegistrationEditorBase*>(getOwner()); }
  };
 
  class ResetAction : public CommandAction
  {
  public:
    ResetAction(SoView2DRigidRegistrationEditorBase* owner) : CommandAction(owner, "ResetManualRegistration") {}
 
    void execute() override { getWidget()->doReset(); }
  };
 
  ResetAction* _resetAction;
};