SoCSOEditorExtension.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 <SoCSOSystem.h>
 
#include "SoCSOVisualizationSettings.h"
#include "../SoCSOEditorTools.h"
 
#include <ThirdPartyWarningsDisable.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/sensors/SoFieldSensor.h>
#include <ThirdPartyWarningsRestore.h>
 
#include <View2DPosition.h>
#include <SoView2D.h>
 
 
class SoView2DCSOExtensibleEditor;
 
class SOCSO_EXPORT SoCSOEditorExtension : public SoNode
{
  SO_NODE_HEADER(SoCSOEditorExtension);
 
protected:
  SoCSOEditorExtension();
  ~SoCSOEditorExtension() override;
 
public:
 
  void setExtensibleEditor(SoView2DCSOExtensibleEditor* extensibleEditor) { _editor = extensibleEditor; }
 
  virtual void activate(SoView2DCSOExtensibleEditor* extensibleEditor) { setExtensibleEditor(extensibleEditor); }
  virtual void deactivate() {}
  virtual void buttonMaskChanged() {}
  virtual void editingOnChanged() {}
 
  virtual void startDrawing(View2DSliceList* ) {}
  virtual void drawingDone() {}
  virtual void setVisibleCSOs(const std::vector<CSODrawCSOInfos>& drawCSOInformation,
                              const CSODrawView2DInfos& view2DInfos,
                              SoView2DCSOExtensibleEditor* editor);
 
  virtual void draw(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& sliceInfo, SoView2DCSOExtensibleEditor* editor);
  virtual void drawSecondPass(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& sliceInfo, SoView2DCSOExtensibleEditor* editor);
  virtual void drawOverlay(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& sliceInfo, SoView2DCSOExtensibleEditor* editor);
  virtual void drawAdditionalGeometry(const CSODrawView2DInfos& view2DInfos, SoView2DCSOExtensibleEditor* editor);
 
  static void initClass();
 
  virtual void createStartPressAt(const SoPointerPosition& pos) = 0;
  virtual void createDragMoveTo(const SoPointerPosition& pos) = 0;
  // Returns whether to continue with this action.
  virtual bool createEndPress(int clickCount) = 0;
  virtual void pointerPositionIfAllowedAt(const SoPointerPosition& pos) = 0;
 
  virtual void selectAndMoveStartPressAt(const SoPointerPosition& pos) = 0;
  virtual void selectAndMoveDragMoveTo(const SoPointerPosition& pos) = 0;
  virtual SoPointingAction* selectAndMoveEndPress(int clickCount) = 0;
 
  virtual void insertSeedPointStartPressAt(const SoPointerPosition& ) {}
  virtual void insertSeedPointDragMoveTo(const SoPointerPosition& ) {}
  virtual SoPointingAction* insertSeedPointEndPress(int ) { return nullptr; }
 
  virtual void bulgeStartPressAt(const SoPointerPosition& ) {}
  virtual void bulgeDragMoveTo(const SoPointerPosition& ) {}
  virtual SoPointingAction* bulgeEndPress(int ) { return nullptr; }
 
  virtual void pointerPosition(const SoPointerPosition&) {}
  virtual void pointerLeftWindow() {}
 
  virtual bool isCreationAllowed() const { return allowCreation.getValue() == 1; }
  virtual bool isCreationAllowedAt(const SoPointerPosition& /*pos*/) const { return isCreationAllowed(); }
  virtual bool isModificationAllowed() const { return allowModification.getValue() == 1; }
  virtual bool shouldRenderCSOs() const { return shouldRender.getValue(); }
  virtual bool canCreateCSOs() const { return false; }
  virtual ml::CSO* getActiveCSO() const { return _hitCSO; }
 
  virtual bool expectsToCreateCSO() { return false; }
 
  SbString getCreatorExtensionId() const { return extensionId.getValue(); }
  void setActiveCSOList(ml::CSOList* hitCSOList);
  void setSelectAndMoveInformation(ml::CSOList* hitCSOList, ml::CSO* hitCSO, ml::CSOSeedPoint* hitSeedPoint,
                                   ml::CSOPathPoints* hitPathPoints, float hitDistance);
  void setCSOUnderMouse(ml::CSO* cso);
  ml::CSO* getCSOUnderMouse() const { return _csoUnderMouse; }
 
  bool hasSelectedSeedPoint() const { return _hitSeedPoint != nullptr; }
  bool hasSelectedCSO() const { return _hitCSO != nullptr; }
 
  virtual SbString getSubType() const { return _subType; }
  virtual bool shouldRenderSpecific(ml::CSO* cso) const;
  virtual bool shouldRenderGeneral(ml::CSO*) const { return false; }
  virtual bool isDefaultRenderer() const { return false; }
  virtual bool isModificationEditor() const { return false; }
  virtual void resetCache() {}
 
  virtual void cancel() {}
  virtual int cursorShape() const { return SoViewerProxy::CROSS_CURSOR; }
  virtual bool deleteSeedPoint(ml::CSO* cso, ml::CSOSeedPoint* );
  ml::CSOSeedPoint* getPreviousSeedPoint(ml::CSOSeedPoint* seedPoint) const;
 
  SoSFString extensionId;
  SoSFBool allowCreation;
  SoSFBool allowModification;
  SoSFBool allowSeedPointInteraction;
  SoSFBool shouldRender;
  SoSFMLBase inVisualizationSettings;
 
  SoSFEnum selectionCursor;
  SoSFEnum interactionForbiddenCursor;
 
  SoSFInt32 csoIdUnderMouseCursor;
 
  virtual void mouseWheelEventReceived(SoMouseWheelEvent::Orientation , int , View2DEvent* ) {}
 
  virtual  bool evaluateHitPoint(const ml::Vector3& worldPosition, View2DSliceList* slicelist, ml::CSOList* csoList,
                                 const ml::CSOBoundingBox& slabBB, SoView2DCSOExtensibleEditor* editor,
                                 ml::CSO*& localHitCSO, ml::CSOSeedPoint*& localHitSeedPoint,
                                 ml::CSOPathPoints*& localHitPathPoints, float& distance);
 
  void reset() { initMembers(); }
 
  ml::CSOVisualizationSettings* getVisualizationSettings();
 
  bool shouldShowCSOForCurrentTimePoint(const CSODrawView2DInfos& view2DInfos, ml::CSO* cso);
 
  void sendCSOEventsOnCancel(ml::CSO* cso);
  virtual void sendCSOEventsOnCancel(ml::CSOList* csoList);
 
 
protected:
 
  virtual void initMembers();
 
  SoView2DCSOExtensibleEditor* _editor;
 
  ml::CSOListPtr     _hitCSOList;
  ml::CSO*           _hitCSO;
  ml::CSOSeedPoint*  _hitSeedPoint;
  ml::CSOPathPoints* _hitPathPoints;
  float              _hitDistance;
  ml::CSO*           _csoUnderMouse;
 
  void sendCSONotificationRepaint();
  void sendCSONotificationMove();
  void sendCSONotificationFinishInteraction();
  void sendCSONotificationResetInteractionState();
  void sendCSONotificationInsertSeedPoint();
  void sendCSONotificationNewCSOStarted();
 
  void setExtensionIdAsSubType() { _subType = extensionId.getValue().getString(); }
 
  virtual void setCreationData(const SoPointerPosition& pos, ml::CSO* newCSO);
 
  void extensionIdCB(SoField*);
 
  ml::CSOVisualizationSettings _visualizationSettings;
 
  SbString _subType;
 
  SoCSOEditorTools::LineRenderSettings getLineRenderSettingsOnSlice();
 
  SoCSOEditorTools::LineRenderSettings getLineRenderSettingsForCSO(ml::CSO* cso);
 
  void drawPathPoints(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos,
                      const CSODrawSliceInformation& drawSliceInfo, const SbVec2f& shadowOffsetDevice, SoView2DCSOExtensibleEditor* editor);
  void renderPathPoints(const CSOPathPointsRenderSettings& renderSettings, const CSODrawCSOInfos& csoInfos,
                        const CSODrawView2DInfos& view2DInfos, const std::vector<CSOSliceCrossing>& pathPointsLists, GLint lineMode, const SbVec2f& shadowOffsetDevice);
 
  void drawPathAndCrossingPoints(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos,
                                 const SbVec2f& shadowOffsetDevice, const std::vector<CSOSliceCrossing>& pathAndCrossingPoints, GLint lineMode);
 
  void drawShape(int style, SoView2DCSOExtensibleEditor* editor, ml::CSOVisualizationSettings* visualizationSettings,
    float deviceX, float deviceY, float size, float lineWidth = 1.f);
 
  void drawSeedPoints(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos,
                      const CSODrawSliceInformation& drawSliceInfo, SoView2DCSOExtensibleEditor* editor);
 
  void drawFixedSizeCircleAt(float deviceX, float deviceY);
 
  bool isCSOVisible(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& drawSliceInfo, SoView2DCSOExtensibleEditor* editor);
 
  ml::Vector3 getTransformedPosition(const CSODrawView2DInfos& view2DInfos, const ml::Vector3& position);
 
  void mapWorldToDevice(const SoPointerPosition& pos, const ml::Vector3& worldPosition, float& deviceX, float& deviceY);
  void mapWorldToDevice(View2DSliceList* slicelist, const ml::Vector3& worldPosition, float& deviceX, float& deviceY);
  ml::Vector3 mapDeviceToWorld(const SoPointerPosition& pos, float deviceX, float deviceY);
  ml::Vector3 mapWorldToVoxel(const SoPointerPosition& pos, const ml::Vector3& worldPosition);
  ml::Vector3 mapWorldToVoxel(const SoPointerPosition& pos, const SbVec3f& worldPosition);
  ml::Vector3 mapVoxelToWorld(const SoPointerPosition& pos, const ml::Vector3& voxelPosition);
 
  SbVec2f nonShadowOffset() const { return SbVec2f(0,0); }
  SbVec2f shadowOffset() const { return SbVec2f(1,1); }
  GLint getLineMode(ml::CSO* cso);
  void setupGLForCSO(const CSODrawCSOInfos& csoInfos);
  void setupGLShadow(float generalAlpha=1.0f);
  void glSetAlpha(float alpha);
  float getDepthAlpha(int maxSliceDistance, int currentSliceDistance) const;
 
  bool doesCSOTimePointMatchCurrentTimePoint(const CSODrawView2DInfos& view2DInfos, ml::CSO* cso);
};